Planet Eclipse

Tom Schindl: E4 – A new area for RCP/RIA-Applications

Thu, 02 Jul 2009 22:38:36 +0000

I’m on the road to prepare my example for the E4 talk I’m delivering on the Eclipse-Developers-Day in Karlsruhe and I have to say that in my eyes E4 is going to open up a new world for Eclipse-RCP-Developers.

Though RCP-Applications written in 3.x might not look too bad no one can deny that the UI-Design is coming from an IDE background and compared to modern Web-UIs it looks boring (which is not a bad thing per se for business applications). The problem in 3.x is that it is very hard to impossible to change the L&F of your application.

E4 provides different multiple solutions to fix the L&F:

Declarative-Styleing through CSS
The possibility to define your own renderes to exchange Widget A through Widget B if CSS is not enough to theme your application

To demostrate what you can achieve when you combine the 1st and 2nd possibility I create a small screencast

where you see the famous E4-Photo-Application revamped

A second example application is our E4-Contacts-Demo created and maintained by Kai Tödter which shows advanced css-styles like radial gradients.

I use this application to show you another nice thing you can do with E4’s declarative styling support. You can adjust the styling of your application while it is running so that you can experiment with various font and color settings WITHOUT shutting down your application.

If all this would not be enough you can run the unmodified code (please take this literally) from the example application above in your browser using the RAP-Framework.

If you are interested in E4 and what’s going on behind the scenes of the next major Eclipse-Release I hope to see you in Karlsruhe on Tuesday July 7th.

Martin Lippert: Slides from Talk at Java-Forum-Stuttgart 2009

noreply@blogger.com (Martin Lippert) — Thu, 02 Jul 2009 18:33:15 +0000

Today I gave a talk on building dynamic applications with OSGi at the Java-Forum-Stuttgart 2009. This was mostly the talk I gave (and prepared) together with Kai Tödter and Gerd Wütherich for previous conferences. Here are the slides:

Patterns and Best Practices for Dynamic OSGi Applications (pdf)

The talk were in the main hall of the conference center and it was fun standing on that huge stage... :-) And of course I got completely confused during the talk while switching between the demo application and a slide showing a screenshot of that demo app - picking up every possible embarrassment... ;-)

Bryan Hunt: Running Rational Team Concert (Jazz) on Eclipse 3.5 / Mac OS X

Thu, 02 Jul 2009 18:22:16 +0000

Rational Team Concert 2.0 has been released. With a little work, you can get the client running on Eclipse 3.5 and the server running on Mac OS X.

Server

The Jazz team does not officially support running the server on OS X, and a download that runs on OS X out-of-the-box is not available. With a couple of minor modifications, the Linux server download will run on OS X just fine.

Download the Express C Server for Linux.
Unzip the download
Launch the Terminal
cd jazz/server
rm -rf jre (the Linux JRE is obviously not needed on OS X)
Edit tomcat/conf/server.xml. You need to modify the Connector specification for port 9443. Search for SSL_TLS and change it to TLS. Also change the next line from IbmX509 to SunX509. The resulting Connector specification should look like:

<Connector port="9443"
               connectionTimeout="20000"
               maxHttpHeaderSize="8192"
               maxThreads="150"
               minSpareThreads="25"
               maxSpareThreads="75"
               enableLookups="false"
               disableUploadTimeout="true"
               acceptCount="100"
               scheme="https"
               secure="true"
               clientAuth="false"
               keystoreFile="ibm-team-ssl.keystore"
               keystorePass="ibm-team"
               sslProtocol="TLS"
			   algorithm="SunX509"
			   URIEncoding="UTF-8" />

Edit server.startup and server.shutdown changing JRE_HOME from `pwd`/jre to /System/Library/Frameworks/JavaVM.framework/Home
Launch the server ./server.startup

If you want to make sure the server started correctly, you can tail -f tomcat/logs/catalina.out and watch the server startup. If you see any exceptions thrown, something went wrong. If all goes well, the last message you see in the log should be:

INFO: Server startup in xxxxx ms

To get started right away, launch Safari and point it to https://localhost:9443/jazz login with User: ADMIN and Password: ADMIN. You can use this admin account to create a personalized account. Don’t forget to give yourself a Developer license.

Client

These instructions are not specific to Mac OS X – they should work for any OS.

The Jazz team does support a Mac OS X Client as an incubator project, but the client is based on Eclipse 3.4. You can download the client and get the jazz bundles to work in an Eclipse 3.5 environment. The Jazz client has dependencies on the following features:

With the exception of SDO, all of the features can be installed from the Galileo update site. To get SDO, add the EMF releases update site and install the SDO runtime from the EMF 2.4.2 release.

From the downloaded client, move all of the sub-folders in jazz/client/eclipse/jazz to your Eclipse 3.5 dropins folder. You could use P2 to install the contents of those sub-folders; however, you must manually check every bundle to be installed. I’d rather spend 10 seconds doing a drag-and-drop rather than 15 minutes checking checkboxes.

After you launch the client, you should be able to open the Team Artifacts view and create a connection to the repository at https://localhost:9443/jazz

Next Steps

See the Jazz web site for tutorials on getting started.

Dave Carver: XText for RelaxNG

noreply@blogger.com (David Carver) — Thu, 02 Jul 2009 17:03:06 +0000

So, I decided to try and create an XText Grammar for the RelaxNG Compact Syntax. Mixed results so far, mainly having to do with my lack of knowledge on the XText grammar and it's mapping to EBNF.

Here is what I have so far:


grammar org.oasisopen.relaxng with org.eclipse.xtext.common.Terminals

generate relaxng "http://www.oasis-open.org/relaxng"

terminal Letter:
   ID;

terminal CHAR:
   '#x9' | '#xA' | '#xD' | ('#x20'..'#xD7FF') | ('#xE000'..'#xFFFD') | ('#x10000'..'#x10FFFF');  

terminal NewLine:
   '#xA' | '#xD' | ('#xA' '#xD');
 
terminal NameStartChar:
   ":" |
   ('A'..'Z') |
   "_" | 
   ('a'..'z') |
   ('#xC0'..'#xD6') | 
   ('#xD8'..'#xF6') | 
   ('#xF8'..'#x2FF') | 
   ('#x370'..'#x37D') | 
   ('#x37F'..'#x1FFF') | 
   ('#x200C'..'#x200D') |
   ('#x2070'..'#x218F') | 
   ('#x2C00'..'#x2FEF') |
   ('#x3001'..'#xD7FF') |
   ('#xF900'..'#xFDCF') |
   ('[#xFDF0'..'-#xFFFD') |
   ('#x10000'..'#xEFFFF');

terminal NameChar:
   NameStartChar | "-" | "." | ('0'..'9') | '#xB7' | ('#x0300'..'#x036F') | ('#x203F'..'#x2040');

Model :
   (elements += TopLevel);

TopLevel:
   Decl* (Pattern | GrammarContent*);
    
Decl:
   'namespace' (IdentifierOrKeyWord '=' NamespaceURILiteral) |
   'default' 'namespace' (IdentifierOrKeyWord) '=' NamespaceURILiteral |
   'datatypes' IdentifierOrKeyWord '=' Literal;

Pattern:
   'element' NameClass '{' Pattern '}' |
   'attribute' NameClass '{' Pattern '}' |
   Pattern (',' Pattern)+ |
   Pattern ('&' Pattern)+ |
   Pattern ('|' Pattern)+ |
   Pattern '?' |
   Pattern '*' |
   Pattern '+' |
   'list' '{' Pattern '}' |
   'mixed' '{' Pattern '}' |
   Identifier |
   'parent' Identifier |
   'empty' |
   'text' |
   (DataTypeName) DataTypeValue |
   DataTypeName ('{' Param* '}') (ExceptPattern) |
   'notAllowed' |
   'external' AnyURILiteral (Inherit) |
   'grammar' '{' GrammarContent* '}' |
   '(' Pattern ')';
   
Param:
   IdentifierOrKeyWord '=' Literal;

ExceptPattern:
   '-' Pattern;

GrammarContent:
   Start | Define |
   'div' '{' GrammarContent* '}' |
   'include' AnyURILiteral (Inherit) ('{' IncludeContent* '}');

IncludeContent:
   Define | Start |
   'div' '{' GrammarContent* '}';

Start:
   'start' AssignedMethod Pattern;

Define:
   Identifier AssignedMethod Pattern;

AssignMethod:
   '=' |
   '|=' |
   '&=';

NameClass:
   Name |
   NsName (ExceptClassName) |
   AnyName (ExceptClassName) |
   NameClass '|' NameClass |
   '(' NameClass ')';

Name:
   IdentiferOrKeyWord | CName;

ExceptNameClass:
   '-' NameClass;

DataTypeName:
   CName |
   'string' |
   'token';

DataTypeValue:
   Literal;

AnyURILiteral:
   Literal;

NamespaceURILiteral:
   Literal | 'inherit';

Inherit:
   'inherit' '=' IdentifierOrKeyWord;

IdentifierOrKeyWord:
   Identifier | KeyWord;


Identifier:
   (NCName .. KeyWord) |
   QuotedIdentifier;


CName:
   NCName ':' NCName;

NsName:
   NCName ':*';

AnyName:
   '*';

Literal:
   LiteralSegment ('~' LiteralSegment)+;

LiteralSegment:
   '"' (CHAR .. ('"' | NewLine))* '"' |
   "'" (CHAR .. ("'" | Newline))* "'" |
   '"""' (('"') ('"') (CHAR .. '"'))* '"""';

KeyWord:
   "attribute"
   | "default"
   | "datatypes"
   | "div"
   | "element"
   | "empty"
   | "external"
   | "grammar"
   | "include"
   | "inherit"
   | "list"
   | "mixed"
   | "namespace"
   | "notAllowed"
   | "parent"
   | "start"
   | "string"
   | "text"
   | "token";

NCName:
   NCNameStartChar NCNameChar*; /* An XML Name, minus the ":" */
    
NCNameChar:
   NameChar - ':';
    
NCNameStartChar:
   Letter | '_';
    
Name:
   NameStartChar (NameChar)*;
    
Names:
   Name ('#x20' Name)*;
    
Nmtoken:
   (NameChar)+;
    
Nmtokens:
   Nmtoken ('#x20' Nmtoken)*;

QuotedIdentifier:
    '\' NCName;

Some of the errors I can figure out...others are just baffling. Particular the ones where it can't find the Rule even though it's been editted. Help from the XText gurus out their would be appreciated.

BioClipse: Bioclipse 2.0 Release Candidate 5

noreply@blogger.com (Ola Spjuth) — Thu, 02 Jul 2009 15:13:52 +0000

Today, Bioclipse 2.0 Release Candidate 5 (versioned 2.0.0.RC5) was released with primarily a fix in the atom typing done when editing chemical structures, and a less stricter handling of SDFiles. The release requires a fresh download from Sourceforge, and we kindly ask beta-testers for bug reports on the bugs.bioclipse.net.

Sven Efftinge: Xtext scopes and EMF index in action

noreply@blogger.com (Sven Efftinge) — Thu, 02 Jul 2009 14:29:35 +0000

This is a post about scoping and how to use the EMF index for that. It is in some sense a practical follow up on another blog post about the general idea behind indexing and scoping in Xtext. The topic is somewhat advanced and bleeding edge. This post describes the needed steps to get the current index based default scoping up and running. I've prepared a small screencast demonstrating the result in action. The example language can be downloaded from here.

Today, the common way to do cross resource references in Xtext is to do it via resource URIs. That is if you want to reference a model element (EObject) from another resource, you typically put the whole resource on the scope by adding a corresponding import. Example:

import "platform:/resource/my.project/src/othermodel.dsl"

//.. refer to elements from othermodel.dsl

The corresponding default scoping is very simplistic. Every object in the current resource and in the referenced resources can be referenced by its simple name (as long as it has a 'name').

Although this is very easy to understand, it has it's limitation when it comes to more sophisticated design. If you for instance want to hide some elements or have duplicate simple names in different packages (this can be the case if you use elements, which are developed by others).

In many programming languages we have the notion of namespaces, which are much more flexible and powerful. Java, for instance, is file system agnostic. Although it forces you to put the files into folders which correspond the packages, it ultimately is just based on namespaces (packages, types).
That said Java's namespace mechanism is also a bit limited. For instance I cannot have imports in nested namespaces but only per file. And I cannot nest packages but only classes and interfaces.

Scala and C# both allow to have multiple nested packages within one file and you can put imports per namespace, so that imported names are only visible within that namespace.

In order to demonstrate how to use the index together with Xtext, I've implemented a DefaultIndexBasedScopeProvider which implements a similar semantic. There's a small example I've prepared, where you can see how it can be used. It is mainly a matter of configuring the different implementations with Guice. Programming is not needed as long as you're happy with the defaults.

Here's how it works

The index registeres a builder, which is invoked on resource changes. In order to make your model elements visible, you'll have to contribute a so called Indexer using an extension point.

<extension point="org.eclipse.emf.index.indexer">
<indexer class="org.eclipse.xtext.example.DomainmodelExecutableExtensionFactory
                  :org.eclipse.xtext.index.DefaultDeclarativeResourceIndexer"
            fileextensions="dmodel"/>
</extension>

Please ignore the ExecutableExtensionFactory, which is declared in order to make any executable extension Guice aware, that is you can use dependency injection. This is a different topic and might be covered by another blog post.

The actual class to be instantiated is the one after the colon (':'): The DefaultDeclarativeResourceIndexer, which delegates to an instance of IQualifiedNameProvider, which itself is injected. This means that its implementation can be arbitrarily changed.
The contract of a name provider is very simple: it computes a qualified name for an element, if it returns null, the element is not indexed and hence not referable.

By default we use a DefaultDeclarativeQualifiedNameProvider, which if not otherwise specified looks up a simple name (if there's an attribute 'name') and concatenates it to the qualified name of its parent. It's named 'declarative' because you're able to change the described default behavior per type by just adding a method like this:

String qualifiedName(MyType foo) {
  // compute different qualified name for MyTypes
  // ...
}

It will automatically dispatch to this method as soon as it has to compute a qualified name for an instance of MyType.

With this in place we'll have our elements automatically indexed as long as they are in a project, which have the index nature enabled. Being indexed means that they are globally visible by their qualified name, which is comparable to how public Java elements are globally visible as soon as they are on the classpath.

What's next?

In order to use the index and have it injected into your components (e.g. your scope provider) you'll have to configure the singleton instance from the index bundle into your Guice module. In the example the corresponding binding goes into the UI module and looks like this:

public IndexStore bindIndexStore() {
 return EmfIndexUIPlugin.getDefault().getIndexStore();
}

With that in place you can inject the index store by just adding a dependency in your code:

@Inject
private IndexStore store;

Guice will automatically put the instance into such declared dependencies.
Now that we have a binding for IndexStore we can add the index based scoping to the runtime module:

public IndexStore bindIndexStore() {
 return new PersistableIndexStore();
}
  
@Override
public Class bindIScopeProvider() {
 return DefaultIndexBasedScopeProvider.class;
}

Note the additional IndexStore binding, which is overridden by the binding we previously added to the UI module, but is needed in order to use this stuff at runtime (i.e. without running within exquinox). So it gets active as soon as you run without UI.

How the DefaultIndexBasedScopeProvider works

The DefaultIndexBasedScopeProvider
- looks up EAttributes with name 'importNamespace'
- and translates the globally unique qualified name into shorter ones using those import statements.

By default qualified names with or without a wildcard at the end are supported. For an import of a qualified name the simple name is made available as we know from e.g. Java, where

import java.util.Set;

makes it possible to refer to 'java.util.Set' by its simple name 'Set'.
Contrary to Java the import is not active for the whole file but only for the namespace it is declared in and its child namespaces. That is why you can write the following in the example DSL:

package foo {
  import bar.Foo
  entity Bar extends Foo {
  }
}

package bar {
  entity Foo {}
}

Of course the declared elements within a package are as well referable by their simple name:

package bar {
  entity Bar extends Foo {}
  entity Foo {}
}

Of course the following would as well be ok:

package bar {
  entity Bar extends bar.Foo {}
  entity Foo {}
}

Disclaimer
All this is in a very early stage. The index is not finished and its architecture is not settled down yet. Also the scope provider implementation might be changed in future (I'm sure it will).
Additionally, there are other things around this which we have to work on before considering this mature.

But as I know that there are a lot of bleeding edge users out there, I wanted to share the current state, so you might find a starting point to play with it. The index is an enabler for more advanced functionality in Xtext and in EMF based development in general. So expect it to become an important part in Eclipse Modeling.

Feedback is highly appreciated and should either go to the newsgroup for Xtext (the scoping part) or to the EMFT newsgroup (the index part), because the index project is a component under EMFT.

Vasanth Dharmaraj: Portable Eclipse and Portable Java

Thu, 02 Jul 2009 14:24:53 +0000

I like portable software. I carry around a bunch of them in my flash drive. I just found out that both Java and Eclipse are available as portable versions at PortableApps.com. The Java version they have is Java 6 update 14 but Eclipse is stuck at 3.4.2.

Eclipse uses portable Java, so Java need not be installed in the PC to run it. Nice. The portable version has some trouble finding the workspace but once you correct the path it works fine.

I updated the Eclipse binaries in to the just released 3.5 and it work great too. Nice way to take Eclipse and your work with you.

Ed Merks: Talking About Connected Data Objects

noreply@blogger.com (Ed Merks) — Thu, 02 Jul 2009 13:46:29 +0000

My personal Berlin tour guide, Eike Stepper, and I did a Galileo Series Podcast about CDO with James Sugrue the other day.

Eike and his rapidly growing team are doing some extremely cool things with CDO, so you might be interested to find out more.

Greg Wilkins: Continuations to Continue

Thu, 02 Jul 2009 11:11:39 +0000

Jetty-6 Continuations introduced the concept of asynchronous servlets to provide scalability and quality of service to web 2.0 applications such as chat, collaborative editing, price publishing, as well as powering HTTP based frameworks like cometd, apache camel, openfire XMPP and flex BlazeDS.

With the introduction of similar asynchronous features in Servlet-3.0, some have suggested that the Continuation API would be deprecated. Instead, the Continuation API has been updated to provide a simplified portability run asynchronously on any servlet 3.0 container as well as on Jetty (6,7 & 8). Continuations will work synchronously (blocking) on any 2.5 servlet container. Thus programming to the Continuations API allows your application to achieve asynchronicity today without waiting for the release of stable 3.0 containers (and needing to upgrade all your associated infrastructure).

Continuation Improvements

The old continuation API threw an exception when the continuation was suspended, so that the thread to exit the service method of the servlet/filter. This caused a potential race condition as a continuation would need to be registered with the asynchronous service before the suspend, so that service could do a resume before the actual suspend, unless a common mutex was used.

Also, the old continuation API had a waiting continuation that would work on non-jetty servers. However the behaviour of this the waiting continuation was a little different to the normal continuation, so code had to be carefully written to work for both.

The new continuation API does not throw an exception from suspend, so the continuation can be suspended before it is registered with any services and the mutex is no longer needed. With the use of a ContinuationFilter for non asynchronous containers, the continuation will now behaive identically in all servers.

Continuations and Servlet 3.0

The servlet 3.0 asynchronous API introduced some additional asynchronous features not supported by jetty 6 continuations, including:

The ability to complete an asynchronous request without dispatching
Support for wrapped requests and responses.
Listeners for asynchronous events
Dispatching asynchronous requests to specific contexts and/or resources

While powerful, these additional features may also be very complicated and confusing. Thus the new Continuation API has cherry picked the good ideas and represents a good compromise between power and complexity. The servlet 3.0 features adopted are:

The completing a continuation without resuming.
Support for response wrappers.
Optional listeners for asynchronous events.

Using The Continuation API

The new continuation API is available in Jetty-7 and is not expected to significantly change in future releases. Also the continuation library is intended to be deployed in WEB-INF/lib and is portable. Thus the jetty-7 continuation jar will work asynchronously when deployed in jetty-6, jetty-7, jetty-8 or any servlet 3.0 container.

Obtaining a Continuation

The ContinuationSupport factory class can be used to obtain a continuation instance associated with a request:

    Continuation continuation = ContinuationSupport.getContinuation(request);

Suspending a Request

The suspend a request, the suspend method is called on the continuation:

  void doGet(HttpServletRequest request, HttpServletResponse response)
  {
    ...
    continuation.suspend();
    ...
  }

After this method has been called, the lifecycle of the request will be extended beyond the return to the container from the Servlet.service(...) method and Filter.doFilter(...) calls. After these dispatch methods return to, as suspended request will not be committed and a response will not be sent to the HTTP client.

Once a request is suspended, the continuation should be registered with an asynchronous service so that it may be used by an asynchronous callback once the waited for event happens.

The request will be suspended until either continuation.resume() or continuation.complete() is called. If neither is called then the continuation will timeout after a default period or a time set before the suspend by a call to continuation.setTimeout(long). If no timeout listeners resume or complete the continuation, then the continuation is resumed with continuation.isExpired() true. There is a variation of suspend for use with request wrappers and the complete lifecycle (see below):

    continuation.suspend(response);

Suspension is analogous to the servlet 3.0 request.startAsync() method. Unlike jetty-6 continuations, an exception is not thrown by suspend and the method should return normally. This allows the registration of the continuation to occur after suspension and avoids the need for a mutex. If an exception is desirable (to bypass code that is unaware of continuations and may try to commit the response), then continuation.undispatch() may be called to exit the current thread from the current dispatch by throwing a ContinuationThrowable.

Resuming a Request

Once an asynchronous event has occurred, the continuation can be resumed:

  void myAsyncCallback(Object results)
  {
    continuation.setAttribute("results",results);
    continuation.resume();
  }

Once a continuation is resumed, the request is redispatched to the servlet container, almost as if the request had been received again. However during the redispatch, the continuation.isInitial() method returns false and any attributes set by the asynchronous handler are available.

Continuation resume is analogous to Servlet 3.0 AsyncContext.dispatch().

Completing Request

As an alternative to completing a request, an asynchronous handler may write the response itself. After writing the response, the handler must indicate the request handling is complete by calling the complete method:

  void myAsyncCallback(Object results)
  {
    writeResults(continuation.getServletResponse(),results);
    continuation.complete();
  }

After complete is called, the container schedules the response to be committed and flushed.

Continuation resume is analogous to Servlet 3.0 AsyncContext.complete().

Continuation Listeners

An application may monitor the status of a continuation by using a ContinuationListener:

  void doGet(HttpServletRequest request, HttpServletResponse response)
  {
    ...
    
    Continuation continuation = ContinuationSupport.getContinuation(request);
    continuation.addContinuationListener(new ContinuationListener()
    {
      public void onTimeout(Continuation continuation) { ... }
      public void onComplete(Continuation continuation) { ... }
    });
    
    continuation.suspend();
    ...
  }

Continuation listeners are analogous to Servlet 3.0 AsyncListeners.

Continuation Patterns

Suspend Resume Pattern

The suspend/resume style is used when a servlet and/or filter is used to generate the response after a asynchronous wait that is terminated by an asynchronous handler. Typically a request attribute is used to pass results and to indicate if the request has already been suspended.

  void doGet(HttpServletRequest request, HttpServletResponse response)
  {
     // if we need to get asynchronous results
     Object results = request.getAttribute("results);
     if (results==null)
     {
       final Continuation continuation = ContinuationSupport.getContinuation(request);
       
       // if this is not a timeout
       if (continuation.isExpired())
       {
         sendMyTimeoutResponse(response);
         return;
       }
       
       // suspend the request
       continuation.suspend(); // always suspend before registration
       
       // register with async service.  The code here will depend on the
       // the service used (see Jetty HttpClient for example)
       myAsyncHandler.register(new MyHandler()
       {
          public void onMyEvent(Object result)
          {
            continuation.setAttribute("results",results);
            continuation.resume();
          }
       });
       return; // or continuation.undispatch();
     }
     
     // Send the results
     sendMyResultResponse(response,results);
   }

This style is very good when the response needs the facilities of the servlet container (eg it uses a web framework) or if the one event may resume many requests so the containers thread pool can be used to handle each of them.

Suspend Continue Pattern

The suspend/complete style is used when an asynchronous handler is used to generate the response:

  void doGet(HttpServletRequest request, HttpServletResponse response)
  {
     final Continuation continuation = ContinuationSupport.getContinuation(request);
     
     // if this is not a timeout
     if (continuation.isExpired())
     {
       sendMyTimeoutResponse(request,response);
       return;
     }
     
     // suspend the request
     continuation.suspend(response); // response may be wrapped.
     
     // register with async service.  The code here will depend on the
     // the service used (see Jetty HttpClient for example)
     myAsyncHandler.register(new MyHandler()
     {
       public void onMyEvent(Object result)
       {
         sendMyResultResponse(continuation.getServletResponse(),results);
         continuation.complete();
       }
     });
   }

This style is very good when the response does not needs the facilities of the servlet container (eg it does not use a web framework) and if an event will resume only one continuation. If many responses are to be sent (eg a chat room), then writing one response may block and cause a DOS on the other responses.

Continuation Examples

Chat Servlet

The ChatServlet example shows how the suspend/resume style can be used to directly code a chat room. The same principles are applied to frameworks like cometd.org which provide an richer environment for such applications, based on Continuations.

Quality of Service Filter

The QoSFilter(javadoc), uses suspend/resume style to limit the number of requests simultaneously within the filter. This can be used to protect a JDBC connection pool or other limited resource from too many simultaneous requests.

If too many requests are received, the extra requests wait for a short time on a semaphore, before being suspended. As requests within the filter return, they use a priority queue to resume the suspended requests. This allows your authenticated or priority users to get a better share of your servers resources when the machine is under load.

Denial of Service Filter

The DosFilter(javadoc) is similar to the QoSFilter, but protects a web application from a denial of service attack (as best you can from within a web application). If too many requests are detected coming from one source, then those requests are suspended and a warning generated. This works on the assumption that the attacker may be written in simple blocking style, so by suspending you are hopefully consuming their resources. True protection from DOS can only be achieved by network devices (or eugenics :).

Proxy Servlet

The ProxyServlet uses the suspend/complete style and the jetty asynchronous client to implement a scalable Proxy server (or transparent proxy).

Gzip Filter

The jetty GzipFilter is a filter that implements dynamic compression by wrapping the response objects. This filter has been enhanced to understand continuations, so that if a request is suspended in suspend/complete style and the wrapped response is passed to the asynchronous handler, then a ContinuationListener is used to finish the wrapped response. This allows the GzipFilter to work with the asynchronous ProxyServlet and to compress the proxied responses.

Where do you get it?

You can read about it, or download it with jetty or include it in your maven project like this pom.xml.

Eric Rizzo: Screencast: Creating an Eclipse download package "from scratch"

noreply@blogger.com (Eric Rizzo) — Wed, 01 Jul 2009 22:25:48 +0000

If the cave you've been living in does not have Internet service, then perhaps it will come as news to you that Galileo was successfully released last week. It's a truly impressive feat to release so reliably so many projects year after year - you'd think that corporate internal and consumer software projects would take note and figure out what it is that enables the yearly release train to succeed when so many projects deliver late, over budget, or not at all. But, I digress...

Being a recent immigrant to the Nation of Mac, I was among the glad to see the Cocoa port graduate from incubation. However, all is not 100% happy in Eclipse+Mac land. The Eclipse Packaging Project (EPP), the small group that produces those easily consumable downloads, the themed packages of plug-ins built on top of the core platform, has limited resources. And with limited people, they can not produce the packages for every hardware/OS platform on which Eclipse is known to run. Of particular interest to me is the conspicuous absence of EPP package builds for 64-bit OS X. After some discussion, it appears we the community can't make a 64-bit build happen until the first "service release" of Galileo, sometime in the Fall. I'm disappointed, but I (mostly) understand the position that EPP is in.

So, what do we do if we want to make full use of all the 64-bit goodness of our operating system and Java 6 JVM? Well, it turns out that re-constructing the EPP packages from the "base platform" SDK is not all that difficult. Ekke Gentz has already blogged some text+picture instructions; my screencast below brings the process to life.

Note: the URL of the EPP update site used in the screencast is

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

Kenn Hussey: On Falling...

noreply@blogger.com (Kenn Hussey) — Wed, 01 Jul 2009 22:22:01 +0000

It's been just under two years now since I left the mother ship for an opportunity with Embarcadero, and I've seldom looked back... until today. On this day, when most other Canadians are celebrating the birth of our great nation and the freedom it affords its citizens, I'm faced with commemorating a new found freedom of my own. I've been exiled from Cubicle Nation.

This isn't exactly the kind of change I had in mind when I wrote my last blog entry, but I'm committed to facing it with an open mind (seeing as I have no choice). I don't know what I'll be doing for income yet (if you have any suggestions, I'd love to hear them), but in the meantime I thought it would be an apt occasion to take another wordle snapshot of my blog (exactly six months after the last one).

So far, 2009 has been a challenging year. But, a friend of mine told me recently that a kick in the pants is still a step forward, and I'm inclined to agree. I really should be seeing this as more of a beginning than an end, and I'm sure that once I've landed with two feet firmly planted on my next venture, this will be obvious in hindsight. One thing is for certain, though. I'll not be looking back again.

Chris Aniszczyk: Training for Eclipse Galileo and p2

Wed, 01 Jul 2009 18:41:04 +0000

As part of the Eclipse Galileo release, we updated all of our training courses to reflect the latest release:

We have also added two new courses to cover two popular topics, Equinox p2 and migrating to Galileo RCP:

We are also offering our courses online now. If you’re interested in any of these courses, please email us.

Jens von Pilgrim: User Report: Migrate from oAW Xtext to TMF Xtext

noreply@blogger.com (Jens v.P.) — Wed, 01 Jul 2009 18:31:13 +0000

With Eclipse 3.5 comes the new version of Xtext, called TMF Xtext. Since I had to switch to Eclipse 3.5 in order to keep GEF3D running on the latest Eclipse version, I decided to migrate from the old openArchitecture Xtext (oAW Xtext) to the new TMF version.

Fortunately the Xtext documentation contains a section about migrating from oAW Xtext to TMF Xtext. Frankly, I was a little bit afraid (never change a running system). But at least I hadn't implemented any content assist or other editor extensions yet, so I hoped that it wouldn't be too hard.

Before you read on, please note that I'm only an Xtext user. I don't know any internal details about Xtext. Maybe some of my problems can be solved more efficiently, if that is the case, I would be more then happy if you leave me a comment. My first intention was to migrate my already running grammar as fast as possible, with as few modifications as possible.

The Setting

I have written a model transformation language, and it consists of an Xtext grammar (with about 90 rules), an interpreter for executing the language, and other things which I didn't expected to be involved in the migration, as a debugger component or other user-interface stuff. An Xtend-based M2M transformation exists which modifies the generated ecore model in order to set some default values, add some workarounds for existing oAW bugs, and do other things. In order to migrate my application, I had to

migrate the grammar
adapt the M2M-transformation
adapt client code which uses the model and the Xtext API

In the following old versions are highlighted with a light red back and the new ones with a light green background.

Migrating the Grammar

As described in the Xtext documentation, I had to replace "Enum" with "enum", and add two new lines at the beginning of the grammar.

Since "with" has become a keyword. Thus I had to rename "with" in my grammar :

RuleXY: ... ( "with" with=Block)? ...

into

RuleXY: ... ( "with" _with=Block)? ...

This also caused some small changes in the model and the client code. Is there a way to use Xtext keywords as a reference names?

Backtracking

Apparently the parser generation (or some settings) has changed, too. E.g., the following rule worked with the oAW Xtext version:

ParameterReference: QualifiedParameterReference|SimpleParameterReference;
SimpleParameterReference: type=Type (name=ID)?;  
QualifiedParameterReference: type=Type name=ID;

The idea of these rules is to force the definition of a name in case of qualified parameter references and to make it optional in simple ones.
Unfortunately these rules are not working with the new version. Since ANTLR is a LL-parser, there are some constraints on how to define the grammar. There is a document explaining how to remove backtracking from a grammar, unfortunately some of the described techniques cannot be used with Xtext. In some cases I was able to fix the problem by rewriting my grammar, as in this example: I simply had to reorder the first rule:

ParameterReference: SimpleParameterReference|QualifiedParameterReference;
SimpleParameterReference: type=Type (name=ID)?;  
QualifiedParameterReference: type=Type name=ID;

In some cases I couldn't find a solution (maybe it is possible, but I'm not an LL/LR-expert). Actually I'm not the first one with this problem, and there is a posting in the TMF newsgroup about this. If you cannot rewrite your grammar, you need backtracking (and lookahead). Thanks to this posting, I was able to fix the problem. I had to edit the MWE-file from

<fragment class="org.eclipse.xtext.generator.AntlrDelegatingFragment" />

<fragment class="de.itemis.xtext.antlr.XtextAntlrGeneratorFragment">
   <options k="2" backtrack="true" memoize="true"/>
</fragment>

Note that you have to install the itemis generator fragment from http://download.itemis.com/updates as described in the Xtext documentation (page 62).
Maybe I'm going to "left factor" my grammar in a future version, but for now I only wanted to get my application running.

Lexer Rules

In the oAW version, lexer rules were defined with the keyword "native", which has been changed to "terminal". Not mentioned in the migration guide yet: INT was redefined in the new version. I had rewritten the definition in the old version in order to remove the optional sign (as my language is handling this itself). This is the old INT definition:

Native INT: ('-')?('0'..'9')+

And here's the new one:

terminal INT: ('0'..'9')+

In my case I could remove my own definition since the new one matches my requirements. In other cases, this might be a trap.

According to the documentation, it should be possible to define the type of a terminal rule now. I tried this as follows:

terminal FLOAT returns ecore::EFloat: ('0'..'9')*'.'('0'..'9')+;

As a matter of fact, the code is generated as expected, but the parser still returns a String, which leads to a ClassCastException. So I removed the type definition and added a convenient method to my model, as described below. I assume this is a bug or something, I will file a report later on ;-). Since the old version always returned Strings, my code was prepared for that, anyway.

OrmPackage missing

I don't know exactly why or when, but at some point in time my grammar file contains got an error marker:

- WrappedException: java.lang.ClassNotFoundException: com.sun.java.xml.ns.persistence.orm.OrmPackage"

This bug seems to be fixed already, fortunately it is possible to generate the model and code from the grammar, even with this error.

Unassigned Actions

In the oAW Xtext version, a model element was assigned whenever a non-abstract rule was hit. My grammar contained the following rule:

NullLiteral: "null";

This rule is not working with the new TMF Xtext version. As found in the documentation "by default the object to be returned by a parser rule is created lazily on the first assignment". Although I've read that passage, I was not aware of the consequences. In the new version, an element is not automatically created when the rule is hit, but only when an assignment is to be executed. That is, a rule which contains only terminals does not create a model element, as in the example above. While this first example is obvious, the problem is sometimes hidden. Here is another more tricky example:

Block: "{" (statements+=BlockStatement)* "}";

If no "BlockStatements" are specified, that is in case of an empty block ("{}"), no block element is created at all. I posted that problem to the newsgroup, and Sebastian Zarnekow immediately solved my problem (Thank you very much, Sebastian!).
The solution is to use unassigned actions, which forces the creation of an element of the specified type. So I had to change the rules above as follows:

NullLiteral: {NullLiteral} "null";
Block: {Block} "{" (statements+=BlockStatement)* "}";

I figure this is a bitchy trap, especially if there is an optional assignment.

Model Changes

I'm already using an Xtend M2M-transformation to adjust the generated ecore model. TMF Xtext supports this mechanism, I simply had to rename my Xtend extension into MitraPostProcessor.ext (Mitra is the name of my language, by the way).

Enumeration NULL values

There are some adjustments necessary due to changed behaviour of Xtext. Most notable: There is no "NULL" value generated for enumerations. Also, it is not possible to define a hidden enumeration in the grammar, which might could have solved that problem. IMHO, this is a major drawback, as this makes a postprocessing of the created ecore file necessary.

But they can be added to the M2M transformation. Unfortunately, I didn't got this problem solved with Xtend, I posted that to the TMF newsgroup. This is at least one solution using Java, although I would prefer a pure Xtend solution:

process(ecore::EPackage p):
 addNullValue(p, "VisibilityModifier") ->
 ... ;

Void addNullValue(ecore::EPackage p, String toEnum):
 doAddNullValue( (ecore::EEnum) p.getEClassifier(toEnum) );
 
Void doAddNullValue(ecore::EEnum e):
 JAVA de.feu.MitraPostProcessorHelper.addNullValue(org.eclipse.emf.ecore.EEnum);

And this is the Java extension:

public class MitraPostProcessorHelper {

 public static void addNullValue(org.eclipse.emf.ecore.EEnum e) {
  for (EEnumLiteral literal : e.getELiterals()) {
   literal.setValue(literal.getValue() + 1);
  }
  EEnumLiteral nullLiteral = EcoreFactory.eINSTANCE.createEEnumLiteral();
  nullLiteral.setName("NULL");
  nullLiteral.setLiteral("NULL");
  nullLiteral.setValue(0);
  e.getELiterals().add(0, nullLiteral);
 }
}

In order to make a literal the default value, it must be the first defined literal. This is why e.getELiterals().add(0, nullLiteral); is required, simply adding the literal with e.getELiterals().add(nullLiteral); doesn't work.

Java Body Annotation in the Ecore Model

In the old version, Xtext didn't create the genmodel and no code. I added this feature and I also edited the generated code after is was created using oAW extension. Since Xtext is doing the code generation now automatically, I didn't feel that comfortable with manually editing the generated model code anymore. So I decided to add Java annotations to the ecore model in order to add some tiny helper methods. This is how body annotations are added to an ecore model in Xtend:

Void addJavaBodies(ecore::EPackage p):
 let ecorePackage = p.getEcorePackage():
 p.getEClassifier("Bounds").addOperation("isMany",
     ecorePackage.getEClassifier("EBoolean"),
       'return upper==-1 || upper>1;') ->
   ...;
/*
This is a hack in order to retrieve the ecore package itself. This is usually
done with a Java extension, but I did not want to add a Java extension here.
The trick is to retrieve the package by navigating to the container of an ecore
type (here a String).
*/
cached ecore::EPackage getEcorePackage(ecore::EPackage p):
  (ecore::EPackage)
  ( ((ecore::EClass) (p.getEClassifier("MetamodelDeclaration")))
    .getEStructuralFeature("type").eType.eContainer
  );
 

create ecore::EOperation addOperation(ecore::EClassifier c, String strName, ecore::EClassifier type,  String strBody):
 setName(strName) ->
 setEType(type) ->
 eAnnotations.add(addBodyAnnotation(strBody)) ->
 ((ecore::EClass)c).eOperations.add(this);


create ecore::EOperation addOperation(ecore::EClassifier c, String strName, ecore::EClassifier type, 
 List parameters,
 String strBody):
 setName(strName) ->
 setEType(type) ->
 parameters.collect(e|((List)e).setParameter(this)) ->
 eAnnotations.add(addBodyAnnotation(strBody)) ->
 ((ecore::EClass)c).eOperations.add(this);

create ecore::EParameter setParameter(List parameter, ecore::EOperation op):
 setName((String)parameter.get(0)) ->
 setEType((ecore::EClassifier) parameter.get(1)) ->
 op.eParameters.add(this)
;

create ecore::EAnnotation addBodyAnnotation(ecore::EOperation op, String strBody):
 setSource("http://www.eclipse.org/emf/2002/GenModel") ->
 this.createBody(strBody) ->
 op.eAnnotations.add(this);

create ecore::EStringToStringMapEntry createBody(ecore::EAnnotation anno, String strBody):
 setKey("body") ->
 setValue(strBody) ->
 anno.details.add(this);

API Changes

So far I found three API changes which required changes in my code. These changes are rather simple and briefly explained in the following.

NodeUtil.getNode(..)

First of all, NodeUtil.getNode(EObject); has changed. There is no type Node anymore. I had to change my code from

Node node = NodeUtil.getNode(eobj);

NodeAdapter adapter = NodeUtil.getNodeAdapter(eobj);
AbstractNode node = null;
if (adapter != null) {
 node = adapter.getParserNode();
}

Resources and Setup

For (JUnit) tests, I have to call a setup method in order to register Xtext's resource implementations and my model. This is now simply achieved via a generated setup method. This is the setup method I'm using now in JUnit tests:

public static void setup() {
   System.setProperty("org.eclipse.emf.ecore.EPackage.Registry.INSTANCE",
   "org.eclipse.emf.ecore.impl.EPackageRegistryImpl");
   MitraStandaloneSetup.doSetup();

No DSL-specific Editor Class

A little bit surprising at first is the absence of a DSL specific editor class, in my case MitraEditor. Instead, the general Xtext editor class is used, DSL specifics are injected using Google Guice as described in the Xtext manual. Most surprising is the new syntax found in the plugin.xml which is used to inject things. Here is the declaration of my editor using the new notation (the plugin.xml is generated):

<extension point="org.eclipse.ui.editors">
   <editor
       class="de.feu.MitraExecutableExtensionFactory:org.eclipse.xtext.ui.core.editor.XtextEditor"
       contributorClass="org.eclipse.ui.editors.text.TextEditorActionContributor"
       default="true"
       extensions="mitra"
       id="de.feu.Mitra"
       name="Mitra Editor">
   </editor>
</extension>

The attribute "class" defines the Guice module to be created and the editor class. Unfortunately I need the editor class in order to add breakpoint markers (for my debugger plugin). The old version looks like this:

public class MitraBreakpointAdapterFactory implements IAdapterFactory {
 public Object getAdapter(Object adaptableObject, Class adapterType) {
  if (adaptableObject instanceof MitraEditor) {
    ...

How do I identify the mitra editor in the new version? First of all, instead of a generated DSL specific editor, an XtextEditor is used (this class is found in plugin org.eclipse.xtext.ui.core). Then the current language can be retrieved via getLanguageName(). This is the new version:

public Object getAdapter(Object adaptableObject, Class adapterType) {
 if (adaptableObject instanceof XtextEditor) {
  XtextEditor xtextEditor = (XtextEditor) adaptableObject;
  if ("de.feu.Mitra".equals(xtextEditor.getLanguageName())) {
  ...

Note that the name of the editor class has to be changed in the plugin.xml of the debug plugin accordingly.

Summary

After applying the changes described above, my language worked as expected (at least all the tests are green and my application is running). Since I haven't written any extensions for content assist or other UI things, I only had to adjust the grammar, my M2M-transformation and the code a little bit. If you do not have an M2M-transformation, you may have to add it in order to add the missing NULL values for enumerations -- I assume this is the case quite often.

TMF Xtext adds some very nice features (grammar mixings, improved linking/cross references feature with ILinkingService, serialization with formatter, return types, and tree rewrite actions). These features will simplify my hand written code immensely, and I'm looking forward using them. Last but not least, since Xtext is now part of the Eclipse modeling package, it is much easier to install an Xtext based DSL and editor.

Last but not least: Kudos to the Xtext team! The new version looks really nice! And many thanks for the great and fast (newsgroup) support!

Dave Carver: Eclipse Galileo: Setting up PDT 2.1 and XDebug support

noreply@blogger.com (David Carver) — Wed, 01 Jul 2009 17:58:10 +0000

Typically when working on PHP files I don't have much of a need to setup a debugger. However, I've recently had to go through some really nasty PHP 4 code. It was one big massive mess of nested if then else statements no functions, and a crap load of global variables. PHP is a good utility language, but some of the people writing the code need to read Uncle Bob's Clean Code book.

My development machine is a Ubuntu box and I have eclipse Galileo Java EE package installed with PDT 2.1 added as well. There is a decent blog entry at Hodge title
Debugging PHP Applications with Xdebug and Eclipse PDT. However you can simplify some of the steps.

Use apt-get or Synaptic to install apache2, php5, php5-cli, and the php5-xdebug module.
Go to the terminal and restart apache2: sudo /etc/init.d/apache2 restart
Follow the rest of the steps outline in Hodge's article for making sure XDeubg is turned on and enabled.

There is no need to download and compile xdebug yourself, as it's already in the Ubuntu apt repository. If you follow the rest of his steps for setting up PDT for XDebug, you should be ready to debug.

Heiko Behrens: Xtext at DemoCamp London in June 2009

Wed, 01 Jul 2009 13:44:11 +0000

This Monday the Eclipse DemoCamp took place in London at Skills Matter. You will find a comprehensive review at InfoQ by Alex Blewitt where you can read about NatTable (Dan Pollitt) and JQantLib/OSGi (Richard Gomes) as well as Xtext. And thanks to Eren Aykin you will find a video podcast of the latter, too!

This time I tried to spread the idea of DSLs with chess and different ways of expressing moves within the game. In the first part of my presentation I processed cryptic notations like “Rd2-c2″ or more natural equivalents such as “rook at d2 moves to c2″ to work with them as true Java objects and eventually visualized chess fields. Second, I tried to emphasize the value of DSLs in today’s software projects where we implemented another DSL live at the DemoCamp in the end. You will find my slides at SlideShare again.

It was quite informative to chat with the Eclipse folks in London afterwards. Most of them have a pragmatic view at modeling and tools in general. I really appreciate this! Thank you, Neil, for organizing this event and inviting via twitter.

Source Code

Loading chess DSL text files as Java objects:

package org.xtext.example.chess;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.xtext.resource.XtextResourceSet;
import org.xtext.example.ChessStandaloneSetup;

public class JavaTest {

	public static void main(String[] args) {
		String filename = "some/path/MyModel.chess";
		Game g = getGame(filename);
		System.out.println(g.getWhitePlayer() + " vs. " + g.getBlackPlayer());
		for (Move m : g.getMoves())
			System.out.println(m.getSource() + " to " + m.getDest());
	}

	private static Game getGame(String filename) {
		ChessStandaloneSetup.doSetup();
		ResourceSet rs = new XtextResourceSet();
		Resource res = rs.getResource(URI.createFileURI(filename), true);
		return (Game) res.getContents().get(0);
	}

}

Ekkehard Gentz: [galileo] Manage Plug-ins (bundles) of Eclipse Target Platform

Wed, 01 Jul 2009 13:25:31 +0000

Part 6 of my Galileo Reviews around Target Platforms. An Overview of this blog series can be found here.

We finished part 5 with a Target Definition containing Plug-ins (bundles) from different kinds of locations:

Fine-tuning the Selection of Plug-ins

At the moment all Plug-ins from all added Locations are selected. You can display the Content together with your Locations on the first page checking “Show Plug-in content” …

… or you switch to the “Content” Tab where you have some more control.

You can check if Source Bundles should be shown or not and also group the content:

Group by None (plain view, all Plug-ins sorted by ID)
Group by Filepath
Group by Location

And as usual there’s a Search field to make it easy to find Plug-ins:

But the most important is the little ckeckbox which allows you to

Select Plug-ins
Deselect Plug-ins

Now its easy for you to fine-tune your Plug-ins and save the selection in the Target Definition file.

There’s also the option to “Add Required” – you can test if after Selecting / Deselecting all Required Bundles are selected in your Target Definition.

Attention: this option perhaps Selects Plug-ins you Deselected before without giving you an information which Plug-ins are re- selected to fullfill the requirements !

Defining the Environment

Beside the “Content” tab there’s also an “Environment” tab:

If your Target Environment is the same as your IDE (running Host platform) is running from, then you can leave this empty.

But its usual that you have some different Environments where your product should run – even if you only develop for one OS.

per ex. under OSX you should test and run under JVM 5 cocoa 32-bit, JVM 5 cocoa 64-bit, JVM 6 cocoa 64-bit, JVM 5 carbon.

Its a good idea at first to start with the same Environment then your IDE is running and later duplicate the Target Definition file for different Environments.

Or another strategy could be to put all (OS – specific fragments etc) into one Target Platform Definition and have different Launch configurations using different Environments / Plug-ins / Fragments. But thats a story for another blog and outside of the “Galileo Review Scope”.

The only thing you should have in mind now:

if the Environment is empty – the Environment from your running Host is used
if you enter values for the Environment this will be used as initial values if you create new Launch Configurations
In your Launch Configurations you can overwrite the values from your Target definition

Lets go back to the Preferences Page “Preferences -> Plug-in Development -> Target Platform“

Updating Plug-ins (bundles) of your Target Platform

The Preference Page shows the active and all available Target Platforms:

As you already learned you can add (and move) or remove Target Definitions from here.

Edit… is nearly the same then from the Target Definition Editor described above.

Hint: I had sometimes the problem, that my selections of Plug-ins were destroyed, esp. if using the search-field on the Contents page, but it wasn’t easy reproduceable. So its a good idea to have a backup or put the Target definitions under CVS – then its easy to compare and restore.

To see if there are newer versions of your Plug-ins you can start a “Reload…” – your Sources will be contacted and newer Plug-ins fetched. Double-clicking to Edit the Target Definition does the same job.

But this works only, if its the same version and only the Qualifier changed. This means its great and easy to use if you always need the newest I-Build of the same Version.

If you need a new Version (Update), then you should duplicate the Target Definition (do this in your Workspace project), change the title and name to reflect the new version and select the Plug-ins with the new Version or choose another Software Site or Directory. Then its also easy to test per ex. 1.0.0.M1 and 1.0.0.M2 by switching the active Target Platform from Preferences.

The next part of my blog series will explain you all the new cool views of Eclipse 3.5 helping you to get more informations about the Plug-ins from IDE and Target Platform.

Posted in Eclipse, Equinox, Galileo, P2, PDE

Laurent Goubet: Acceleo 0.8 is out

noreply@blogger.com (Laurent Goubet) — Wed, 01 Jul 2009 13:25:07 +0000

You might already know Acceleo 2.6, the open source model-to-text generator, and wonder how version 2.6 could come down to 0.8. The reason is quite simple : after four years of development outside of Eclipse, Acceleo is now taking a turn (for the better we hope :)) since we began rewriting it within Eclipse as the implementation of the OMG MOF Model to text Transformation Language (MOFM2T) specification. This change and our becoming an Eclipse-hosted project calls for a mandatory incubation period, thus version numbers "0.x".

Acceleo 0.8 already offers basic solutions to migrate existing Acceleo 2.x templates to the new syntax. This migration is still a draft and we are working on improving it so that most "old" templates can be migrated to the new syntax automatically, or with the least amount of manual editing needed. Compatibility with Eclipse itself is detailed on Acceleo wiki page.

This first release of Acceleo as the implementation of the MOFM2T specification already provides most of the tooling that can be expected from an M2T generator. A succinct list can be found on the New and noteworthy wiki page.

Thomas ten Cate: New build instructions

Wed, 01 Jul 2009 10:35:31 +0000

Because of many problems I experienced with Darcs, I converted the EclipseFP repository to Git. I really like the clean and simple model and UI of Darcs, and I’m sorry to see it go, but it was simply too slow and too unreliable. Also, I removed all dependencies on Cohatoe. Without further ado, here are the new and improved instructions in case anyone wants to test-drive my current work.

As usual, this assumes that you have GHC, cabal-install, and git. I tested only on Ubuntu 9.4, but there is no reason why it shouldn’t work on other Unix platforms. There may still be some issues on Windows.

Get Eclipse Galileo (3.5), the distribution named “Eclipse for RCP/Plug-in Developers”. Extraction equals installation.
Get the Scion source:
git clone git://github.com/ttencate/scion.git
(My master branch corresponds to nominolo’s multi_proto_server branch.)
Build and install Scion, the library as well as the server program:
cd scion/lib cabal install cd ../server cabal install
Get the EclipseFP source:
git clone git://github.com/ttencate/eclipsefp.git
Import all Eclipse projects from these repositories into Eclipse. There are 26, so the Multi Project Import/Export plugin might come in handy.
Wait for the build to fail. Yes, that’s right. It will complain about missing files, because ANTLR generated some that Eclipse doesn’t yet know about. Refresh the net.sf.eclipsefp.haskell.core.jparser project, then wait for the build to succeed. (Thanks to Björn Peemöller for pointing this out!)
Hit Run, Run As, Eclipse Application.
In the new Eclipse window that (hopefully) pops up, set the location of the Scion server via Window, Preferences, Haskell, Scion. If you installed it in a fairly standard location, the Autodetect button should do the trick; otherwise, just Browse.
If something doesn’t work, turn on tracing. In the Run Configurations dialog, on the Tracing tab, you can enable tracing options for various plug-ins. These will output to the Console at the bottom of the host Eclipse window. To see the traffic between the Scion client and server, turn on the logs for net.sf.eclipsefp.haskell.scion.client.

A known issue is that you have to save a file before it gets loaded into Scion, so you don’t get type tooltips and go-to-definition until then. This will be resolved in the near future, maybe tomorrow. After nine consecutive days of work, I’m taking a day off now.

Again, please let me know if you tried this. Also let me know if something didn’t work, so I can improve it!

Jerome Benois: Quelques news Spring et Acceleo

Wed, 01 Jul 2009 10:00:00 +0000

Je suis très heureux d'annonçer la sortie imminente de la nouvelle édition de "Spring par la pratique". La parution en librairie est prévu pour le 9 Juillet 2009 et la version ebook est d'ores et déjà disponible.

Un grand bravo à Thierry Templier, Arnaud Cogoluègnes et Julien Dubois qui ont fait un travail de titan sur cette nouvelle version. Vous y trouverez toutes les nouveautés de Spring 2.5 et Spring 3.0 ainsi que des nouveaux chapitres sur Spring Batch ou encore Spring DM.

J'ai eu l'occasion de participer modestement à cette aventure et de contribuer une annexe traitant de l'industrialisation des développements Spring dans Eclipse. Vous devez vous doutez que cette industrialisation est basée sur une approche dirigée par les modèles et utilise le générateur Acceleo

Cette nouvelle version atteignant pas moins de 680 pages, les annexes ne seront pas inclus dans l'édition. Mais elles seront bientôt disponibles pour tous en téléchargement sur le site dédié créé pour l'occasion : http://www.springparlapratique.org. La listes des annexes :

Annexe A : SpringIDE
Annexe B : Développement OSGi dans Eclipse
Annexe C : Industrialisation des développements Spring dans Eclipse

Aussi, je profite de ce billet pour relayer l'annonçe de Freddy sur un événement à ne pas manquer "Eclipse Acceleo Day". La communauté Acceleo se retrouvera le 10 Juillet 2009 à Nantes. Cette événement se déroulera pendant les 10ème RMLL. Vous trouverez toutes les informations ainsi que le programme complet ici.

Inscrivez-vous vite, il ne reste que peu de temps avant la clôture des inscriptions !

Alex Radeski: 64bit Cocoa Galileo Keyboard Problem Fixed (kinda)

noreply@blogger.com (alexr) — Wed, 01 Jul 2009 08:35:11 +0000

I refused to give in to my keyboard problems I posted about yesterday and it looks like a bit of perseverance has paid off.

My problem was to do the the Microsoft Keyboard Mac driver (no surprises there). Specifically the keyboard is a PC keyboard, and it also has a British layout. This is significant because the Mac British keyboard layout is fairly different, and although it worked with Gailieo the keys were all mapped incorrectly.

In the image below you can see the Microsoft British layout. With this selected, neither the USB Keyboard or my MBP keyboard worked in Galilieo. So I searched around and came across a helpful fellow who produces a home brew British PC Keyboard layout (also seen below). With this installed I have British keys, and 64 bit Galileo, yay!

Gorkem Ercan: New Java for S60

noreply@blogger.com (gorkem) — Wed, 01 Jul 2009 08:09:15 +0000

Nokia Java Runtime 2.0 for S60 (JRT 2.0) has been released for beta testing and now available from Nokia beta labs site. This is a package that upgrades the Java runtime on the phone (tested with Nokia 5800 XpressMusic, and N97) with this new one. This is the first time we are testing the independent release/upgrades of Java Runtime from S60 releases. In the future this will allow us to deliver the latest and greatest JRT to older phones.

Some of the new features and improvements that will be noticeable (also listed on release notes) are one-click application installation, application launch user experience, and execution performance. I must tell about a feature that I am proud of and can be interesting to the readers of this blog. The Java installer in JRT 2.0 (the application that installs midlets) is itself a Java application. In fact, the UI(prompts etc. ) for the installer is developed using eSWT. I am very excited about the new installer because it proves that eSWT can be used to create native looking UIs, even ones that are integrated to the system.

Thomas ten Cate: Compiling and error reporting

Tue, 30 Jun 2009 21:12:18 +0000

During the last few days, I have been reinstating error reporting. Previously, EclipseFP would call GHC, collect its output in a Java string, and send that string off to Cohatoe (the now defunct bridge from Java to Haskell). A Haskell module would parse the GHC output using Parsec, return the result back to Java, where EclipseFP would do fancy things with the parsed output.

If this all sounds very roundabout, you’re right. We are already interfacing with Haskell in the form of the Scion server, so why not let it do the compiling and send us (EclipseFP) the result in a formatted way? Thoughts in this direction are under way, but currently hampered by a few factors:

Scion talks with the GHC API, which is single-threaded. This means that during background compiles, every Scion-based function in the IDE would stop working. It should be possible to fix this by letting Scion itself do background compilation, while still servicing requests that do not need to communicate with the GHC API directly, but this requires much work inside the Scion server.
Ideally, when a Cabal file is present, Scion should let Cabal do the building. Unfortunately, Cabal does not play well as a library, because errors will terminate the program. This has been fixed in the upcoming Cabal 1.8, to be released along with GHC 6.12.1 in September.
When a Cabal file is not present, Scion should do something along the lines of “ghc –make”. However, the make functionality is currently still interwoven with the compiler itself. A consequence is that compilation results are only available after all modules have been compiled. A callback for progress reports is in the works for GHC 6.12.1.

In the light of all these obstacles (especially the first one, which cannot be solved by installing a HEAD build of GHC) I decided to keep the current way of calling GHC as an external process. However, this meant that the output parsing had to be rewritten in Java. Moreover, because compiling a large project might take a while, gathering up all output and processing it all at once is not the best approach. My new parser works directly on the output stream from the GHC process, so all errors will appear live in the IDE as soon as GHC spits them out.

With that in place, I sprinkled on some UI code (oh, this makes it sound so easy…) and got things working again. Like error squigglies:

You can hover over the error to get the message. Note that an error marker is also shown in the left margin, and next to the scrollbar. This last one is very convenient if you want to jump to an error in a large source file. These are the kinds of features that Eclipse gives you for free, which is the reason why I chose to do Haskell in Eclipse in the first place. Unfortunately, an error marker on the icon of the editor’s tab is more difficult, so I left that out for now.

The Project Explorer now also shows error markers on files that do not compile:

Parents of files with errors also receive this marker. This makes it easy to locate problems in a large project.

Errors are, as usual, also reported in a special Problems view:

It would be better if only the first line were shown, and could be expanded to show the additional information, but for a first attempt this will do.

If parsing of GHC’s output might fail for some reason, an error will be reported in the Error Log (which contains Eclipse errors, not Haskell errors), and you can always see the raw output in the Console:

Very nice.

There is, however, one small problem currently. This is caused by a mismatch between GHC’s notion of building, and Eclipse’s. When building, EclipseFP will visit all files in the project, then invoke “ghc –make” on them. It suffices to call “ghc –make” only on the file containing the main function, and GHC will take care of the rest. But not only is this approach wasteful: it will also lead to error markers appearing and disappearing as the same file gets compiled (as a dependency) multiple times. My plan for solving this is to add a project option to specify the main module and the name of the main function, so that we can call GHC only on that module. Much more efficient.

Thomas ten Cate: Little rant on modularity

Tue, 30 Jun 2009 21:11:08 +0000

And now, a little rant. Eclipse is, first and foremost, a Java IDE. It tries very hard to be extensible and flexible, so the Java functionality itself, like everything else, is a plug-in, or rather a set of plug-ins called the JDT (Java Development Tools). Very good.

But unfortunately, there is a lot of code in the JDT that does quite generic things, like showing the error markers in the Project Explorer, or on the editor tabs. I often find myself digging through the JDT sources to figure out how the big guys do things, only to find out that they implemented quite common functionality in the JDT that would also benefit many other language-specific plug-ins. Other plug-in writers who want to use this functionality have a choice: either have their plug-in depend on the Java Development Tools, or reproduce all the code in their own plug-in.

Depending on the JDT plug-ins would be a shame, because we’re trying to build a Haskell IDE here. Even though most Eclipse users will have the JDT already installed, we do not want to have to package it with an eventual “Hasklipse” (I hope that name doesn’t stick…) distribution containing an Eclipse platform for Haskell development. Moreover, it is not even always possible to use the classes from the JDT directly: often, they subtly depend on some Java-specific treat.

The alternative, copying and pasting to your own plug-in, is therefore often the best option. It is not pretty, but it works, and it allows you to customize the code to fit your own plug-in better. But I sure wish it wasn’t necessary. For a poor Haskell plug-in developer, even more modularity would be very welcome.

Andrew Overholt: Going to GUADEC

Tue, 30 Jun 2009 17:51:49 +0000

Thanks to the generous sponsorship of the GNOME Foundation and GNOME Travel Committee, on Thursday I’m heading to the Gran Canaria Desktop Summit. This conference is a combination of GUADEC and Akademy and promises to be an excellent week of discussions, presentations, etc.

I’ll be giving a talk on Eclipse, focusing on our work at the Linux Tools project and of course showing the CDT and Mylyn and all the other awesome stuff I can fit into 30 minutes. I’ve been to GUADEC twice before and was really impressed with everyone’s enthusiasm. I’m sure this year will be just as good and I look forward to the inspiration that comes from conferences like this.

Freddy Allilaire: Eclipse Acceleo Day program is available!

noreply@blogger.com (Freddy Allilaire) — Tue, 30 Jun 2009 14:38:00 +0000

The first Eclipse Acceleo workshop will take place on July 10, 2009 in Nantes. More information available here: http://www.acceleo.org/wiki/index.php/EclipseAcceleoDay
The complete program is now available with a lot of interesting talks dealing with Eclipse, MDE, DSM and of course Acceleo ;-)

Hour	Title	Presenter	Affiliation	Language
09:00	Introduction	Etienne Juliot	OBEO	English
09:30	Presentation of a DSM-oriented design and generation environment	Erlé Le Gac	Capgemini	French
10:00	MDA & Acceleo deployment feedbacks	Vincent Fady	Atos Origin	French
10:30	Coffee break
11:00	Acceleo, contribution to the industrialization of developments: Feedback from Bull-Centre de Services Paris	Olivier Leal	Bull	French
11:45	An Open-source Model Driven software development toolset - Lesson learned from Orange Labs	Samuel Liard	Orange Labs	French
12:15	Lunch
14:00	MDSD Scaffolding and Acceleo	Cédric Vidal	Proxiad	English
14:30	Presentation of WISSS (Webapp Is Simple, Stupid and Secure)	François Gaudin	Makina Corpus	English
15:00	Acceleo MTL: a standard alternative for code generation	Cédric Brun	OBEO	English
15:45	Coffee break
16:15	EEF powered by Acceleo MTL - Acceleo MTL ... and punishment!	Goulwen Le Fur	OBEO	English
17:00	Panel

This workshop is free but with mandatory registration (for organisation purposes). Registration details are available here: http://www.acceleo.org/wiki/index.php/EclipseAcceleoDay

Hope to see you there :-)

Dave Carver: Eclipse: RelaxNG Tools

noreply@blogger.com (David Carver) — Tue, 30 Jun 2009 14:24:25 +0000

Most people that work with XML have at least heard of DTDs and XML Schemas. Both are widely used to provide a validation model for the XML document. XML Schema has also been tried to be used as a general purpose modeling language and used within data binding frameworks for code generation. However, XML Schema and DTDs do not necessarily work or are the best fit for all document designs. XML Schema can be very heavy weight, overly wordy, and in general a pain to work with at times. DTDs do not allow data typing, and personally I hate the DTD syntax.

So, if you need the power that XML Schema can provide, but want an easier for humans to read language what are your alternatives. RelaxNG.

Bug 281529 has been opened to help bring a RelaxNG set of tools and frameworks over to the Web Tools Platform Incubator. RelaxNG provides both an XML syntax and a more human friendly Compact Syntax:

Sample Compact Syntax:


element addressBook {
  element card {
    attribute name { text },
    attribute email { text }
  }*
}

In some ways I think the RelaxNG might be a good place for XText and its DSL editor generation abilities. The RelaxNG language is a doman specific language for XML validation. It's compact syntax would seem to fit well into the range that XText can support.

RelaxNG is very popular in the Document centric industries. The Open Document set of grammars are written entirely in RelaxNG. A good set of open source tooling and integration within eclipse is missing for RelaxNG. OxygenXML does contain RelaxNG support but this isn't an open source solution that others can use and contribute to build their own implementations. It would be ideal if we could get all interested players together to work off a common framework to meet the 80% that everybody needs, and then extend where necessary the additional 20%.

Ben Vitale: p2 UI policy and Declarative Services

noreply@blogger.com (Ben Vitale) — Tue, 30 Jun 2009 14:06:31 +0000

This is another post in what is becoming a short (so far only two) series about moving a product from 3.4 to 3.5.

After I got my build working, the next step was making sure that I could update from one product version to the next. I was especially excited about the resolution of https://bugs.eclipse.org/bugs/show_bug.cgi?id=246060 which allows for .qualifier to be replaced in a product version. No longer would I have to manually increment the product version number for purposes of updating to and testing a nightly build.

So my plan was:

Run PDE product build to generate version 1.0.0.abc
Unzip 1.0.0.abc to some location.
Run PDE product build again to generate version 1.0.0.def
Launch 1.0.0.abc, point it at the repository for 1.0.0.def, and update.
...
Profit.

Unfortunately, when I launched 1.0.0.abc, the Install New Software dialog didn't have a way for me to add a new repository. Ditto for the preference page.

Turns out there is a more robust set of p2 UI building blocks in 3.5, which is handy for RCP developers. That is described in great detail here: http://wiki.eclipse.org/Equinox/p2/Adding_Self-Update_to_an_RCP_Application

I should mention that the RCP-p2 example in 3.5 is leaps and bounds ahead of the one from 3.4 (there wasn't one) - so props to the p2 UI team on that.

At any rate, the wiki page tipped me off that there is a UI policy which controls what components are showing and enabled. This policy is implemented as an OSGi declarative service. What really threw me for a loop is that I wasn't trying to do anything special with this policy. I just wanted the stock SDK one since our product is based on the SDK.

Debugging the Policy Behavior

I stepped through the preference page code and discovered that the SDKPolicy wasn't getting discovered as a service (it was just getting an empty Policy every time). So this sent me down the route of launching with -console to see the OSGi console and look for the policy service. After fighting with the filter syntax for the services <filter> console command, I googled a bit more and found these useful runtime options for spitting out verbose DS logging information. I turned those on but I didn't get anything logged. I was pretty stumped at this point.

Then a light bulb came on: maybe declarative services wasn't running at all? A quick ss ds at the console showed that it was RESOLVED but not active! I did a start to spin it up and all of a sudden a deluge of DS logging information printed out. And then SDKPolicy started working, and voila my p2 UI was working.

It turns out the root cause is that we had a custom config.ini in 3.4 to specify a custom osgi.instance.area location. This was screwing up the start level for the ds bundle. I switched the product to generate a config.ini for me, did a new build, and everything worked. I plan to migrate the osgi.instance.area configuration step to a p2.inf file, which is what the platform releng guys do.

Useful Links

[1] Equinox Runtime Options
[2] Explore Eclipse's OSGi Console
[3] Around the world in Java: Getting Started with OSGi Declarative Services
[4] p2 UI policy bug #1
[5] p2 UI policy bug #2

Ekkehard Gentz: [galileo] EPP for Cocoa 64-bit

Tue, 30 Jun 2009 12:13:45 +0000

You know from my Galileo – review – Blogs that I’m now working under OSX Cocoa-64bit.

If you try to download one of the easy-to-start EPP Packages for Galileo, there’s no Cocoa 64-bit – download available.

See a detailed discussion under Bugzilla 281501. Thanks to comment#39 from Markus Knauer there’s a Software Site wich helps you to get it:

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

I also updated my collection of Software Sites here.

Now its easy:

Download SDK Cocoa 64-bit
Install New Software from EPP Packages
Select your Package

and you’re done

Eclipse EPP RCP Cocoa 64-bit

Use the EPP (P2) Software Site, choose your Package:

here are the Details:

Finish -> Restart:

Now its easy to test all EPP Packages under Cocoa 64-bit

Posted in Eclipse, Galileo, OSX, P2

Alex Radeski: Eclipse Galileo, Mac 64bit Cocao Yay!, No keyboard, Boo!

noreply@blogger.com (alexr) — Tue, 30 Jun 2009 12:13:09 +0000

So I've fully switched from Eclipse Ganymede to Galileo, at work and at home. At home I thought I'd try the the Mac Cocoa 64-bit version (available here) to give the new Apple JDK 1.6.0_13 for a spin.

Unfortunately when I fire up the 64-bit Eclipse, I get no input from the keyboard. All mouse driven input woks fine, but I get no joy with the keyboard. I did a bit of fiddling to get it to work, but gave up and reverted to JDK 1.5.x. If The Internet has any advice, I'd love to get it working, it felt really snappy from what I could see...

Since getting my Mac earlier this year, the (weak) Java support is my biggest gripe. Why is Java the poor cousin, my guess is that Apple doesn't want any competition from within, so it's easier to "cripple" Java in OS X. I won't bleat on any more about it, there are plenty more knowledgeable folk blogging about it.

UPDATE: Looks like this is a known issue with attaching PC keyboards to a mac and using Eclipse 64-bit Cocoa.

Emil Crumhorn: Creating a Notification Popup Widget

Tue, 30 Jun 2009 12:00:24 +0000

In this article I will explain how to create a custom widget that displays a popup notification dialog in the bottom right corner of your screen (usually above the toolbar on Windows). Here’s what it will look like when we’re done:

We could custom draw everything which would allow us more control over the widget, but for the sake of this article lets stick to using basic SWT components inside a normal Shell that we will make a bit prettier than your typical SWT Shell.

(Do note this has only been tested on Windows, it’s quite possible tweaks are necessary for other platforms).

The Shell

What we want is a Shell that stays on top of our application (but not on top of all applications) and doesn’t steal the active focus or else it would show up in your task manager or move focus away from where the user is now. We also don’t any normal Shell “trim” borders, we’ll draw our own. Creating it is easy as all of our requirements are available via SWT flags. Thus we can create the Shell as follows:

_shell = new Shell(Display.getDefault().getActiveShell(), SWT.NO_FOCUS | SWT.NO_TRIM);

As we have SWT widgets inside our shell and we intend to use a gradient background on the shell itself, all the widgets need to be transparent. This is done by setting the Background Mode on the shell to SWT.INHERIT_DEFAULT. This tells the widgets to inherit the background of their parents, and gives us what we want. So after we create the shell we simply call;

_shell.setBackgroundMode(SWT.INHERIT_DEFAULT);

So how do we get a gradient background on a shell? It certainly don’t support it by default. You can set a foreground and a background but that’s about it. The trick is to paint an image with the colors we want and use that as the shell’s background. To set it at the right time, we listen to the SWT.Resize event on the shell and do it then with the following code;

_shell.addListener(SWT.Resize, new Listener() {
    @Override
    public void handleEvent(Event e) {
	try {
	    // get the size of the drawing area
	    Rectangle rect = _shell.getClientArea();
	    // create a new image with that size
	    Image newImage = new Image(Display.getDefault(), Math.max(1, rect.width), rect.height);
	    // create a GC object we can use to draw with
	    GC gc = new GC(newImage);

	    // fill background
	    gc.setForeground(_bgFgGradient);
	    gc.setBackground(_bgBgGradient);
	    gc.fillGradientRectangle(rect.x, rect.y, rect.width, rect.height, true);

	    // draw shell edge
	    gc.setLineWidth(2);
	    gc.setForeground(_borderColor);
	    gc.drawRectangle(rect.x + 1, rect.y + 1, rect.width - 2, rect.height - 2);
	    // remember to dipose the GC object!
	    gc.dispose();

	    // now set the background image on the shell
	    _shell.setBackgroundImage(newImage);

	    // remember/dispose old used iamge
	    if (_oldImage != null) {
		_oldImage.dispose();
	    }
	    _oldImage = newImage;
	}
	catch (Exception err) {
	    err.printStackTrace();
	}
    }
});

The Contents

Our shell consists of 3 sections, an image at the top left (which is a normal CLabel). Then a label that contains the header text (also a CLabel), and finally a label which represents our message (a normal Label). We use a Label at the end instead of a CLabel as Labels support wrapping and multi-lines better than the CLabel does. You could of course use pretty much any widgets you want. Here’s an outline of what section each label covers:

We use a GridLayout with some 5px margins (except at the top) and the widgets are created normally without any special magic, so I won’t show that code here (it’s all at the bottom for you to download).

Some Eye Candy – Fading

Shells support alpha values as of SWT 3.4, so we’ll use this to make our “appearing” and “disappearing” a bit prettier. All we need to do to make a shell fade in and out is to have a thread that loops and increases/decreases the alpha channel value for the shell. As we need to be on the Display thread to do this it’s easiest to do it all via a runnable that we let the Display object run for us at a given interval.

We need to remember to continuously check to see if the shell is disposed as it can happen when we’re on a thread. When we’re finished fading in, we want the shell to stay visible for a certain amount of time, and then we want to fade out. So basically the chain is this:

Create shell
Fade in shell
Stay visible for X seconds
Fade out shell
Dispose shell

All these timers are more or less similar in terms of how the code looks, so I’ll show one example here and for the rest you can look at the complete source downloadable below. We have some global variables here that should be explained.

FADE_IN_STEP is how much we increase the alpha value for each iteration.
FINAL_ALPHA is a value that declares what the final alpha value will be for the shell when it stays visible. I find that a slightly transparent shell gives a better effect, so by default this value is 225 (out of 255 which is a solid [opaque] shell).
FADE_TIMER is how long we wait until increasing the Alpha value again. When the shell has reached it’s max-alpha value we call the startTimer() method, which is a thread that sleeps for a certain number of seconds before calling the fadeOut() method.

private static void fadeIn(final Shell _shell) {
    Runnable run = new Runnable() {

        @Override
        public void run() {
            try {
                if (_shell == null || _shell.isDisposed()) { return; }

                int cur = _shell.getAlpha();
                cur += FADE_IN_STEP;

                if (cur > FINAL_ALPHA) {
                    _shell.setAlpha(FINAL_ALPHA);
                    startTimer(_shell);
                    return;
                }

                _shell.setAlpha(cur);
                Display.getDefault().timerExec(FADE_TIMER, this);
            }
            catch (Exception err) {
                err.printStackTrace();
            }
        }

    };
    Display.getDefault().timerExec(FADE_TIMER, run);
}

Stacked Notifications

There’s one last thing we want to support, which is stacked notifications. Assume our notification shell’s entire life-span is about 5 seconds, what if we have another notify call before the first one has finished showing? We could dispose the first shell and replace it with the new one of course, but a much prettier approach is to simply move the previous shell up, and show the new notification below it. The effect of this is something like this (this screenshot was taken just as the old shells started to fade out, hence the higher alpha on them):

What we do to achieve this effect is rather simple. Every time a notification shell is opened, we keep a reference of it in a static array of shells. When it’s faded out (and disposed), it’s removed from the list. Thus, when a new shell is created we simply check to see what’s already in the array and then set the location for each old shell in the array to -heightOfNewNotificationShell (so to speak). Thus, the old shells move up to make room, but continue their fade-in/fade-out cycles just like before.

Further Improvements

Everything could be made prettier than it already is of course, perhaps you want an “X” close button, or different colored text, or rounded shell corners. None of that is in the current code, but the code should give you enough to go on to implement most of that without any major problems.

Also note that I currently use Display.getDefault().getActiveShell() for the parent shell of the popup. You may want to refactor it to use a more permanent shell as otherwise a disposal of whatever the parent shell was whenever the popup was displayed will cause the notification to dispose as well.

The code is not perfect, it’s an example to build on (if you so wish).

Download Code

I’ve created an Eclipse project with the code and also the ImageCache/FontCache/ColorCache classes I use in the code (all they do is keep already used images etc in memory so that they don’t need to be re-created). There’s also a jar with the images I’ve used in this example. If you like them and want more like it, there’s a massive image pack with exactly these icons and more here: Gnome Colors Icons.

Do note you may need to adjust your CLASSPATH settings for the project to reflect the location of your SWT jars.

To run the code, simply run the Tester.java class and push the big button to create a notification. Push it again before the first one fades away to see the stacking. A random image will be used every time you push it.

DOWNLOAD CODE

Conclusion

Hopefully this gives you an insight into how to create a “custom widget” (without much custom painting). Have fun!

Laurent Goubet: EMF Compare graduated!

noreply@blogger.com (Laurent Goubet) — Tue, 30 Jun 2009 08:08:43 +0000

Galileo is out ... and with it came the graduation of EMF Compare to 1.0 at last!

A great deal of improvement has been made in EMF Compare so as to improve user experience and effectiveness. This release sees the usual new differences EMF Compare detects (reference order changes, resource dependencies, ...), and an improved support for the various VCSs (CVS, SVN, ...).

The most outstanding improvement is the ability to compare whole ResourceSets instead of a single model; allowing users to compare fragmented models as well as linked models (UML models referring to profiles, Genmodels referring to ecore models, ...) and thus detecting changes made in the selected models along with changes that can have taken place in their dependencies.

Thanks to a contribution from Moritz Eysholdt, EMF Compare now provides a patch format for model merging. This EPatch format is associated with a textual syntax thanks to XText, allowing for easier editing and improved readability of these patches.

The full list is available on EMF Compare 1.0 new and noteworthy wiki page.

Ekkehard Gentz: [galileo] HowTo define a (complex) Target Platform

Tue, 30 Jun 2009 05:29:40 +0000

Part 5 of my Galileo Reviews around Target Platforms. An Overview of this blog series can be found here.

You have successfully defined a Target Platform for Riena following part 4 of this series. But that was only a very simple definition – all was based on one location: the Galileo Software Site.

Target Platform Locations

But there are more kinds of Target Platform locations.

Add Locations lets you select sources where the Plug-ins come from:

from Software Site (we already did this)
from Installation
from Features
from Directories

Add Plug-Ins from another Eclipse Installation

Thats really cool you can select one of your Eclipse Installations and select this as your Source.

As you already know I’m just working from a Cocoa-64-bit SDK Installation. There’s another Eclipse 3.5 Installation on my disk: Eclipse EPP RCP Cocoa-32-bit:

Select your Eclipse Installation Folder.

“Next >” gives you a preview of the content:

“Finish” adds the Location to your current Target definition:

Add Plug-ins from Features of other Eclipse Installations

Instead of selecting a complete Installation you can also select one or more Features of an Installation:

As before you select the Eclipse Folder of an Installation and then you’ll see the list of the Features contained at this Eclipse Installation.

Normaly the list contains only the highest available versions. Sometimes you want to define a Target Definition from older Versions: then you have to check “use specific version“

You can select one or more Features and click “Finish” to add them to your current Target definition.

Add Plug-ins from 3rdParty Software Site

You can also add as much Plug-ins as you need from as much Software Sites as you need.

As described in an earlier blog of this series you define all your SoftwareSites under Preferences.

Let’s try the UpdateSite Ed Merks blogged about: “Galileo Plus“

Select what you need – after clicking “Finish” your Locations look like:

Add Plug-ins from Directories

As last option you can choose Plug-ins (bundles) stored in Directories. This is very handy if a Plug-in provider has no Software Update sites and provides only downlaods.

Choose a folder containing Plug-ins (bundles):

Clicking on “Next >” gives you a preview:

Click on “Finish” to add the content to your Target Definition.

Fine-tuning your selected Plug-ins (bundles)

Now we have made selections from different kind of locations: Directory, Installation, Feature and Software Site.
You can do some fine-tuning we’ll talk about in my next blog “Manage Plug-ins (bundles) in Eclipse Target Platform”

Posted in Eclipse, Equinox, Galileo, P2, PDE, Riena

Kent Beck: Immovable Object versus Unstoppable Force: Capex and the Marginal Cost of Production

Tue, 30 Jun 2009 02:55:18 +0000

One of the courses I study in the Farmyard Podcast University is economics. I like making sense of the world, and sometimes economics help make sense of the world. Sometimes. Sometimes it seems flatly contradictory. Here is one of those cases.

The theory of production states that in a competitive market, prices will stabilize at the marginal cost of production. That is, if I am a farmer with a bunch of wheat, I will be willing to sell my next kilo at the cost to raise that additional kilo. If seed, fertilizer, and diesel cost me $10 for that kilo, I will rationally take anything more than $10 for it. Since lots of other farmers are also competing to sell wheat, the price will fall to $10. I would be a chump to insist on a higher price and risk not selling at all. I would be a chump to sell for less than my cost of production. Price = marginal cost of production.

The theory or production is used to “logically” justify a price of $0 for information. Since the marginal cost of production (the amount to distribute the next download) is essentially zero, so the story goes, the price for information will tend to zero.

Enter CAPEX

This theory takes a very narrow view of economics. Somebody has to pay for the tractor and the land. In this model, such costs get paid for out of an irrelevantly small slice of the price.

Businesses divide the money they spend in to capital expenditure, CAPEX, and operational expenditure, OPEX. CAPEX is money spent in anticipation of future gain, like buying a new tractor or writing a programming tool. OPEX is money spent in anticipation of immediate gain, like buying seed or paying this month’s bandwidth bill. The distinction between CAPEX and OPEX is important for tax reasons and because balancing the two in various ways can offer different business models.

OPEX is really our friend the marginal cost of production by a different name. Bringing CAPEX into the picture highlights the absurdity of the “price = marginal cost of production” theory as OPEX trends to zero. That little “capital tax” added to every price becomes increasingly significant. What happens when price = marginal cost = $0? Like quantum effects, once you reach a certain scale the rules change. The Newtonian economics of “price = marginal cost of production” are overwhelmed by the need to finance the upfront capital. The form of solution to this has yet to emerge.

Is This Really a Problem?

One of the factors that has kept this dilemma from being a problem to date is increasing capital efficiency. A programmer today can produce software for much, much less than he would have required for the same functionality even ten years ago. In fields like journalism or music, the cost of doing an okay job has likewise fallen dramatically.

The word “okay” is important in that last sentence. There is a difference between an article written by Malcolm Gladwell (on this very topic) and one written by, well, me. But if his costs money and mine is free and you don’t care enough about the difference, he can’t charge for his. I don’t care about charging for mine, because I make my money on, on, on… I’ll get back to you on that.

Cracks are appearing in the system. One of my pressing needs is an efficient environment for collaborating in real-time on code. Many projects have started to provide such functionality, but most (all in the Eclipse world) have stalled short of solving the problem. Increasing capital efficiency in this case can’t overcome the size of the task of solving a difficult programming problem. The capital just isn’t there to solve the whole problem. A group of smart, poor graduate students can’t muster the capital necessary to solve it and a VC would have to be crazy to invest in it, given that no one will pay for a solution. And so a socially, economically significant problem goes unsolved.

I don’t have a resolution of this dilemma. CAPEX is immovable but the pressure for “price = marginal cost of production” is unstoppable. One argument was that in a world of abundance, things that couldn’t be replicated easily, like one’s own physical presence, would increase in value. I am not finding that to be true, but I’m experimenting with selling a remote pair programming session. I’ll get back to you on how it works. In the meantime I have some good ideas waiting for capital, I just can’t promise any payoff. I know I’m not alone.

Peter Friese: Getting Started with Xtext

Mon, 29 Jun 2009 22:17:56 +0000

Xtext has been released as a part of the Eclipse Galileo release train on June 24th, 2009. Xtext is a framework for building DLSs (domain specific languages). In fact, it can be seen as a DSL for defining DSLs.

In this article, we will develop a small DSL for defining entities.

Download and Install

Hop over to http://xtext.itemis.com and download an Xtext distribution matching your platform. We've got all major platforms: Windows, Mac OSX Carbon, Mac OSX Cocoa 64, Mac OSX Cocoa 32, Linux Gtk 64, Linux Gtk 32.

To install, unzip the distribution file to a directory of your liking.

Windows users, please make sure you unzip to a directory near to your filesystem root! Eclipse contains files and folders with long names that might be hard to handle for Windows.

Create a new project

After launching Eclipse and creating a new workspace (or using an existing one), create a new Xtext project by selecting File -> New... Project... -> Xtext Project. In this article, we're creating a DSL for describing entities, so let's go with the following settings:

Main project name: org.xtext.example.entity
Language name: org.xtext.example.Entity
DSL-File extension: entity
Create generator project: yes

Click Finish to let Xtext create the three projects that make up your DSL:

org.xtext.example.entity - this project contains the DSL itself, including all back end infrastructure like the parser and the meta model.
org.xtext.example.entity.ui - as the name implies, this project contains all UI centric code of the DSL: the editor, the outline, content assist and so forth
org.xtext.example.entity.generator - this project contains a code generator which will transform the DSL scripts (aka models) you write in your DSL into something useful. In our example, we will create some POJOs and DAOs from our models.

Upon finishing creating these three projects, Xtext opens a file Entity.xtext, which contains a sample grammar, which we will change in a second.

Define the grammar for your DSL

Next up, we need to define the grammar for our DSL. To make things easier for us, let's first write down a sample model. Please open org.xtext.example.entity.generator/src/model/MyModel.entity and key in the following text:

typedef String
typedef Integer
typedef Date mapsto java.util.Date

entity Person {
  String name
  String surName
  Date birthDay
  Address home
  Address work
}

entity Boss extends Person {
  Person* employees
}

entity Address {
  String street
  String number
  String city
  String ZIP
}

Most of this model should be pretty obvious, but there are two things worth noting:

We define our own list of data types to gain a certain degree of flexibilty, i.e. to map them to different types in the host language, as can be seen for the Date data type, which gets mapped to java.util.Date (we might also decide to map it to java.sql.Date
The star (*) denotes multiplicity. We might also have chosen square brackets (Person[] employees) or something completely different - it's largely a matter of taste.

Let's derive the grammar for this model. Open org.xtext.example.entity/src/org/xtext/example/Entity.xtext, erase its entire contents and enter the following:

grammar org.xtext.example.Entity with org.eclipse.xtext.common.Terminals
generate entity "http://www.xtext.org/example/Entity"

The first line indicates we want the new grammar to be derived from the (built-in) grammar Terminals, which defines some basic terminal rules (like STRING, ID and so forth). If you're interested, CTRL+Click on the language name to navigate to its definition.

The second line defines the name and namespace URI for our own grammar.

Let's now define that our DSL supports types. Add the following lines:

Model:
  (types+=Type)*;

Type:
  TypeDef | Entity;

This tells Xtext that our Model contains any number (i.e. 0..N, as declared by the *) of Types. What exactly a Type is needs to be specified. Apparently, a Type can be either a TypeDef or an Entity:

TypeDef:
  "typedef" name=ID ("mapsto" mappedType=JAVAID)?;

A TypeDef starts with the keyword typedef, followed by an ID making up its name. Following the name, we can optionally (hence the question mark at the end) add a mapsto clause. The fragment mappedType=JAVAID specifies that the TypeDef will later have an attribute named mappedType of type JAVAID. As JAVAID is not yet defined, we need to do so:

JAVAID:
  name=ID("." ID)*;

So, a JAVAID is a sequence of IDs and dots, making up a qualified Java type name, such as java.util.Date.

Next, let's define how to model entities:

Entity:
  "entity" name=ID ("extends" superEntity=[Entity])?
  "{"
    (attributes+=Attribute)*
  "}";

As you might have guessed, Entitys start with the keyword entity, followed by an ID as their name. They may optionally extends another entity. Surrounding a rule call with square brackets means "this is a cross reference", i.e. a reference to an already existing element.

Entitys do have Attributes (any number, to be precise), thus we have to define how Attributes look like:

Attribute:
  type=[Type] (many?="*")? name=ID;

By now, you should be able to read this rule: an Attribute has a type which is a cross reference to a Type (which is either a TypeDef or an Entity), it has an optional multiplicity indicator (the star) and - of course - if has a name.

Your grammar should look like this by now:

grammar org.xtext.example.Entity with org.eclipse.xtext.common.Terminals

generate entity "http://www.xtext.org/example/Entity"

Model:
  (types+=Type)*;

Type:
  TypeDef | Entity;

TypeDef:
  "typedef" name=ID ("mapsto" mappedType=JAVAID)?;

JAVAID:
  name=ID("." ID)*;

Entity:
  "entity" name=ID ("extends" superEntity=[Entity])?
  "{"
    (attributes+=Attribute)*
  "}";

Attribute:
  type=[Type] (many?="*")? name=ID;

Compiling the DSL

Now it is time to see the fruits of our labor. But first, we need to compile our grammar. Xtext will create:

a parser
a serializer
an Ecore meta model
a full blown Eclipse editor

from this grammar. To make this happen, please select org.xtext.example.entity/src/org/xtext/example/GenerateEntity.mwe and select Run As -> MWE Workflow from the context menu. Xtext will now generate the entire infrastructure for your DSL and after a few seconds you should have a shiny new DSL including a great editor.

Taking it for a spin

Seeing is believing, so let's take the DSL editor for a test drive. Select the DSL project org.xtext.example.entity and, from the context menu, select Run As -> Eclipse Application. A second instance of Eclipse will be started.

In this new instance, create a new, empty project (File -> New -> Project... -> General -> Project. Create a new file Sample.entity in the new project.

You can now insert the model we designed above or enter a new model:

Leveraging the model

Now that we've got a fancy editor for our DSL, we want to transform the models we can create with this editor into something meaningful. This, however, will be the topic of the next installment.

More info

Feel free to discuss this article in the comments section of my blog. Should you have any technical questions regarding Xtext, we've got an excellent newsgroup where the committers answer your questions. We also offer professional (commercial) support, i.e. customized trainings to get your team up to speed. Just drop us a note, we're happy to discuss the details with you.

Scott Lewis: Early bird defines the worm!

Mon, 29 Jun 2009 21:00:51 +0000

In his posting All contributions are Equal, some are more equal than others, Robert Konigsberg points out that contributing multiple ways of doing things can easily lead to more user complexity (e.g., by having multiple toString generators).

This is true and in my view, a risk for any system that has many strongly-opinioned contributors (pretty much any large open source project).

Toward the end of his post, he poses a process-level question about how to avoid the situation of some contributions being more equal than others…. I think the solution is the current de facto for Eclipse.org projects and that’s the (frequently unstated) reality that the early bird defines the worm.

When it comes down to it, those that initiate and then follow through on enhancements, fixes, documentation or other contributions get to choose when it comes to actual design decisions. Inevitably, there are design choices that some disagree with, even when all discussion is had completely in the open.

I think the truth of the early bird defines the worm statement is that we should provide incentive to organizations and individuals in the community to be more aggressive about contributing to existing Eclipse projects. This is because waiting for someone else to initiate, design, implement, test and document something often doesn’t work very well.

To some, it may seem like Eclipse Project development is effectively subsidized by others, but this is not true. Even for one’s own usage of Eclipse, contribution and community involvement with Eclipse.org projects pays dividends. There are many ways to contribute, from contributing discussion/ideas, to planning, to new example/app code, to helping to maintain existing code, to documentation, to build support, to testing and bug reporting, to providing bug fixes, to mentoring, and plenty of other kinds of support.

In my view, these are the ways to get your contributions into Eclipse, and influence the community around the software.

Here’s my understanding of where the toString() contribution originated.

Kevin McGuire: Why choice reduces usability

Mon, 29 Jun 2009 20:24:57 +0000

We usually consider choice as being a good thing, whether it be around choice of restaurant, chocolate bar, clothing, or technology. Choice makes us feel empowered, and variety adds richness to life.

Not surprisingly, embedded in the design philosophy of Eclipse is the notion that “choice is good”. Clearly then, if some choice is good, more choice is better. And darn if Eclipse doesn’t give you a LOT of choice! The preferences alone should make any humble programmer feel empowered to tweak the IDE into exactly the shape and behaviour you want.

However, it turns out that in practice, while we believe we want choice, there is good research suggesting that more choice makes us less happy. For an excellent book on the subject, I highly recommend The Paradox of Choice by Barry Schwartz.

I’ve been pondering this a lot lately with respect to user interface design in general, and Eclipse specifically. What we often forget (and Schwartz does a great job of explaining) is that there is a cost to choice. One must understand the choices themselves, one must be informed, otherwise we risk choosing wrong. Not only does that comparison itself imply a cost (learning, weighing), but bad choices cost us more than good ones benefit us. That is, we feel the negative impact of say losing $50 to a greater extent than we feel the positive emotional impact of winning the same amount. Therefore, paradoxially, although we seek choice, we actually prefer not to choose. There’s much more in the Scwartz book and I encourage you to read it.

Thus a common misbelief in UI design is that giving the user more choice will increase the usability of the product. It’s almost always not true. What choice does is increase the utility of the product, because you can use it for more things, or in more ways. But it reduces the usability, because the choice brings with it a cost that the user must bear. (Note that I’m ignoring accessibility related preferences since these obviously increase usability for those who need them).

A favorite example is the following dialog that you get post P2 update.

Now to be clear, I’m not picking on P2, this happens to be a good example, and there are many more throughout Eclipse. Plus, I must confess that I had a hand in this dialog.

The dialog is there to support the set of users who know under which conditions the workspace does not need to be restarted. Personally, I refer to it as the “Feeling lucky, punk?” dialog. Susan and I have had many discussions about this dialog and in keeping with the theme of “just enough rope to hang yourself with” decided to leave it in Eclipse for the power users. For many though, it leaves you scratching your head, or even a little afraid. These “some add-ons”, how do I know which they are? Is there a list? If yes, why doesn’t Eclipse have this list so it doesn’t have to ask me? If such a list can’t exist, then what chance do I have? What happens if I say “No” and don’t restart, will bad things occur? If so, why do you let me do it? If not, then why aren’t two choices sufficient? What are the warning signs that I should’ve said yes, and then what should I do to fix it? It’s asking me if I want to restart, but it’s giving a binary choice (yes/no), plus another choice, so will “Apply Changes” restart or not? And if not, does it mean that “No” didn’t apply the changes? I’m afraid! Mommy!!

Thus we’ve increased utility (advanced users can work more efficiently), but we’ve decreased usability (all users are forced to make a decision with no guidance, where the consequence of picking the non-default is unknowable at that moment).

Next time you go to add a preference or provide a choice dialog, it’s worth considering the cost of the choice and it’s impact on usability. Ask yourself, “Have I really benefitted the majority of my users in providing this? Or have I benefitted a few at what cost to the many?”.

Ben Vitale: Debugging PDE Build and the publisher

noreply@blogger.com (Ben Vitale) — Mon, 29 Jun 2009 17:41:47 +0000

I posted a problem to the PDE newsgroup last week about unexpected requirements in my product feature. This was in the context of moving a 3.4-based product to 3.5.

The general issue was that the director wouldn't install my product because of an unsatisfied requirement. It wasn't clear to me where this requirement was even coming from. Somewhere, there was some metadata in my plugins/features that expressed a dependency that had worked fine in 3.4 but failed in 3.5. My theory was that if I could capture when the publisher was generating the requirement, I'd be able to see the source of that requirement and squash it.

Tracing

First attempt was to turn on tracing for the p2 components. I managed to find the org.eclipse.equinox.internal.p2.core.helpers.Tracing class which listed out the different options. I stuffed those into a .options file:


org.eclipse.equinox.p2.core/debug=true
#org.eclipse.equinox.p2.core/generator/parsing=true
#org.eclipse.equinox.p2.core/engine/installregistry=true
#org.eclipse.equinox.p2.core/metadata/parsing=true
#org.eclipse.equinox.p2.core/artifacts/mirrors=true
#org.eclipse.equinox.p2.core/core/parseproblems=true
#org.eclipse.equinox.p2.core/planner/operands=true
#org.eclipse.equinox.p2.core/planner/projector=true
#org.eclipse.equinox.p2.core/engine/profilepreferences=true
org.eclipse.equinox.p2.core/publisher=true
#org.eclipse.equinox.p2.core/reconciler=true
#org.eclipse.equinox.p2.core/core/removeRepo=true
#org.eclipse.equinox.p2.core/updatechecker=true

Then the trick was to pass along those options to the AntRunner app which drives PDE build. I added -debug path/to/.options into my arguments to AntRunner. Running the build again I got two things, neither of which were helpful:

Passing -debug to the Platform also passes -debug onto Ant, thanks to AntRunner. So my Ant ran in debug mode which really clouded the issue with about 8mb of debug output.
The publisher only outputs two trace statements: start and finish. Nothing about what it is publishing. This may be a candidate for enhancement.

Based on these results, I reasoned that nobody else must be using this technique to solve their p2 problems. Moving on.

Stepping through the publisher

Next up: run AntRunner with Java debug enabled so that I could connect remotely and set breakpoints in the publisher actions. I added the appropriate JVM args to enable the Java wire debug protocol. Started the build again, connected up and started setting breakpoints in various publisher actions.

Since the rogue requirement was getting added to my product feature IU, I added a conditional breakpoint in FeaturesAction to look for that feature being processed.

Then, since the problematic requirement was org.eclipse.core.resources [3.4.0,3.5.0) I added another conditional breakpoint in getVersionRange to watch for incoming feature entries with 3.4.0 as their minimum version.

I did finally discover the problem: I had a bunch of old, outdated entries in my product feature's feature.xml, which included references to several different versions of o.e.core.resources. After I ripped those out, I had a successful build and director install.

Conclusions

Do not pass the debug flag to AntRunner for purposes of debugging platform code unless you are prepared to wade through volumes of output. (I guess this is a feature of AntRunner - https://bugs.eclipse.org/bugs/show_bug.cgi?id=5672)
It was not at all apparent to me to debug p2 actions by setting up a "remote" debug session with PDE build running inside of AntRunner. But it was sure as heck helpful once I figured it out.
I am actually glad that I ran across this problem, and that p2 is enforcing these types of constraints, because it helped me clean up outdated dependencies in my feature.

How are you debugging your p2 builds??

Robert Konigsberg: All contributions are Equal, some are more equal than others

noreply@blogger.com (Robert Konigsberg) — Mon, 29 Jun 2009 16:23:52 +0000

This evening I read Cay Hortmann's article on upgrading to Galileo. (For those of you who do not know Cay, he writes the fantastic Core Java books. I learned Java from the 1.1 version, as well as both the 1.4 and 1.5 versions. He writes great stuff.)

In the article he makes this comment:

There is now an option to generate toString automatically. This is something I've wanted for a long time. Unfortunately, it is not very good. Core Java gives these simple rules for toString:
Use getClass().getName() to print the class name. Then your toString can be inherited.
When you redefine toString in a subclass, first call super.toString(), then add the subclass data.
The Eclipse formatter follows neither of these eminently sensible rules. Maybe in 3.6.

I've not yet seen the toString generator, but having written more than enough toString implementations, I've worried that such a code generator may be less than ideal. Similarly, I've seen the equals and hashCode generators at work, and I also tend to not want to use them.

Given that I work for a company that has so much Java code that "If code was ice cream, it would be a lot of ice cream," [Ref Java Posse 240, 9:15] in addition to having very helpful helper methods for hashCode and equals, I'd love more finely-tuned generators for such critical methods.

But I feel a bit constrained by one of the basic rules guiding Eclipse contributions, as defined by the book Eclipse: Principles, Patterns and Plug-ins:

As the Contribution Rule reminds us, “Everything is a contribution.” And with many contributions, the possibilities are endless.

OK, so let's say I write my own generators for toString, hashCode and equals. Then there are two toString generators in the IDE, one possibly better than the other. Why should the end user be forced to deal with two confusing UI contributions?

Sure, there's also the recent object of my affections, patch fragments, but the patch fragment is a back-door lover.

I want to remove the default contributions altogether, and replace them with something better suited to my environment. But that violates the Contribution Rule. Am I stuck with something less than ideal until Eclipse 3.6, or worse, forever?

What's the solution here?

PS: Has someone picked up on Cay's concerns and logged a bug?

David Green: Hudson Helper for Android

noreply@blogger.com (David Green) — Mon, 29 Jun 2009 16:13:43 +0000

Recently I launched Hudson Helper for iPhone and iPod Touch, enabling Continuous Integration fans to stay in touch with their projects. Android users can get in on the game now too, with Hudson Helper for Android.

Hudson Helper for Android provides all of the same features as the iPhone version including support for multiple servers and authentication. New for this version are build controls: start and stop builds right from your phone. CI can be even more fun with shake-to-build and sound effects.

To get Hudson Helper for Android, search for 'Hudson Helper' in the Google Market on your Android device.

Stéphane Drapeau: SCA Tools Galileo Release

Mon, 29 Jun 2009 15:58:00 +0000

The SCA Tools project has seen an enormous amount of new development since the 2008 Ganymede release. We’ve added an XML editor to make editing and updating SCA-standard assembly files really easy.

For Java developers, it’s now possibly to create an SCA assembly definition and then generate Java code from it. And, if you want to start with some Java you already have, we’ve added a special introspector that will investigate your code and automatically produce an SCA assembly.

Once you’ve created your Java SCA project, you can then run and debug it using the great facilities that Eclipse provides.

We also have made sure that the SCA artifacts you might create are properly validated, helping you spot mistakes early in the process.

We even took the time to update the graphics, giving us a prettier SCA Composite Designer.

For me, the most exciting feature is how we’ve developed the core SCA model to be extensible by people who want to write in extra capabilities into the tools. The heart of the model contains the SCA standard specifications, and different extensions have been created to support the key Open Source SCA runtimes - Apache Tuscany 1.4 and Frascati 0.5. Using the extension mechanisms, it is much more straightforward to add new concepts to SCA and extend the tools to include them.

SCA Tools has been improved a lot. Download SCA Tools 2.0.0 now!

Shaun Smith: OSGi Persistence Slides from OSGi DevCon Europe 2009

noreply@blogger.com (Shaun Smith) — Mon, 29 Jun 2009 15:44:14 +0000

Here are the slides to a short presentation I gave on persistence at OSGi DevCon Europe in Zurich. I had 30 minutes and wanted to do a demo to show that EclipseLink is running nicely in OSGi--it was tough cramming all this in but I did it without a moment to spare. Enjoy the slides and if they spark some questions you can post them here on the blog or on the EclipseLink newsgroup at http://www.eclipse.org/newsportal/thread.php?group=eclipse.rt.eclipselink or the eclipselink-users mailing list.
--Shaun

OSGi Persistence With EclipseLink

View more documents from shaunmsmith.

Polishin' Eclipse: Eclipse DemoCamp in Cracow - Round 3

noreply@blogger.com (Szymon Brandys) — Mon, 29 Jun 2009 14:57:26 +0000

This is the third time when Eclipse DemoCamp was organized in Krakow. On Jun 27 (Saturday) Eclipse fans from Krakow met in Baraka club at Kazimierz in Krakow.

Kazimierz is an old Jewish department of Krakow. You can read more about it here. For us important is the atmosphere there which is in favor for such events.

Since we wanted to celebrate the Galileo release, we didn't fill the whole time with talks and demos.

More than a half of the time was just chatting with beer and pizza in hands. This way we managed to answer more questions and meet more people personally than we could do otherwise.

People came despite the rain. I understand that this could be hard to wake up early on Saturday when it rains. However Eclipse people are tough guys and girls, so rooms at the club were full.

Moreover we found a new application for laptops. Yet another proof that ThinkPads rules :)

The agenda and the list of attendees can be found here.

Don't forget that the next DemoCamp is in November and you are all welcome. Cheers!

BioClipse: Bioclipse 2.0 Release Candidate 4

noreply@blogger.com (Ola Spjuth) — Mon, 29 Jun 2009 14:46:09 +0000

Today, Bioclipse 2.0 Release Candidate 4 (versioned 2.0.0.RC4) was released. The release requires a fresh download from Sourceforge, and we kindly ask beta-testers for bug reports on the bugs.bioclipse.net.

Hopefully this will be the candidate for the 2.0 release.

Tom Schindl: Now that’s cool

Mon, 29 Jun 2009 13:30:43 +0000

If you are following my blog you may have noticed that I invested some hours this weekend in Eclipse-Databinding and GWT.

It was Saturday in the evening when I got the Eclipse-Databinding working inside GWT and I started searching for a decent Table and TableTree-Widget (I looked at the code in the gwt-incubator but that didn’t made me happy). So I thought the RAP people are using Qooxdoo as the underlying JavaScript-UI library what would be if there was a GWT-Binding to this JavaScript-Lib using the GWT-native calling interface and so I started search for such a thing but apparently noone ever tried to write such a thing. So I started reading docs and studying libraries who use this native-calling interface – I’ve never written such a thing before – and voilá it was yesterday around lunch time when I had the first success because one of the GWT-Demos showed up.

The Java code for this small application looks like this:

public class Button extends QooxdooApp {
	@Override
	protected void run(QxAbstractGui application) {
		QxHBox box = new QxHBox();
		box.setSpacing(10);

		QxComposite container = new QxComposite(box);
		container.setPadding(20);

		application.getRoot().add(container, QxOption.left(0), QxOption.top(0));

		QxButton btn1 = new QxButton("Button A", "/icon/22/apps/media-video-player.png");
		container.add(btn1);

		QxButton btn2 = new QxButton("Button B", "/icon/22/apps/internet-mail.png");
		btn2.setEnabled(false);
		container.add(btn2);

		QxToggleButton btn3 = new QxToggleButton("Toggle Button", "/icon/22/apps/internet-web-browser.png");
		btn3.focus();
		container.add(btn3);

		QxRepeatButton btnRepeat = new QxRepeatButton(null,"/icon/22/actions/list-add.png");

		container.add(btnRepeat);

		final QxLabel l1 = new QxLabel("0");
		l1.setDecorator("main");
		l1.setPadding(2, 4);
		l1.setBackgroundColor("white");
		container.add(l1);

		btnRepeat.addExecuteHandler(new ExecuteHandler() {

			public void execute(ExecuteEvent executeEvent) {
				int tmp = Integer.parseInt(l1.getContent()) + 1;
				l1.setContent(tmp+"");
			}
		});
	}

}

and now compare it too the original source:

/* ************************************************************************

   qooxdoo - the new era of web development

   http://qooxdoo.org

   Copyright:
     2004-2008 1&1 Internet AG, Germany, http://www.1und1.de

   License:
     LGPL: http://www.gnu.org/licenses/lgpl.html
     EPL: http://www.eclipse.org/org/documents/epl-v10.php
     See the LICENSE file in the project's top-level directory for details.

   Authors:
     * Sebastian Werner (wpbasti)
     * Fabian Jakobs (fjakobs)

************************************************************************ */

/* ************************************************************************

#asset(qx/icon/${qx.icontheme}/22/apps/media-video-player.png)
#asset(qx/icon/${qx.icontheme}/22/apps/internet-mail.png)
#asset(qx/icon/${qx.icontheme}/22/apps/internet-web-browser.png)
#asset(qx/icon/${qx.icontheme}/22/actions/list-add.png)

************************************************************************ */

qx.Class.define("demobrowser.demo.widget.Button",
{
  extend : qx.application.Standalone,

  members :
  {
    main: function()
    {
      this.base(arguments);

      var box = new qx.ui.layout.HBox();
      box.setSpacing(10);

      var container = new qx.ui.container.Composite(box);
      container.setPadding(20);

      this.getRoot().add(container, {left:0,top:0});

      // Two normal buttons
      var btn1 = new qx.ui.form.Button("Button A", "icon/22/apps/media-video-player.png");
      container.add(btn1);

      var btn2 = new qx.ui.form.Button("Button B", "icon/22/apps/internet-mail.png");
      btn2.setEnabled(false);
      container.add(btn2);

      // Toggle Button
      var btn3 = new qx.ui.form.ToggleButton("Toggle Button", "icon/22/apps/internet-web-browser.png");
      btn3.focus();
      container.add(btn3);

      btn3.addListener("changeChecked", function(e) {
        this.debug("Checked: " + e.getData());
      }, this);

      // Repeat Button
      var img1 = "icon/22/actions/list-add.png";
      var btnRepeat = new qx.ui.form.RepeatButton(null, img1);
      container.add(btnRepeat);

      // Label
      var l1 = new qx.ui.basic.Label("0");
      l1.setDecorator("main");
      l1.setPadding(2, 4);
      l1.setBackgroundColor("white");
      container.add(l1);

      // Listener
      btnRepeat.addListener("execute", function()
      {
        var tempValue = parseInt(l1.getContent()) + 1;
        l1.setContent(tempValue.toString());
      });
    }
  }
});

Afterwards I went outdoors because the weather was just too nice to stay inside but because of my great success in the morning I sat down and implemented a few more widgets to show you the GWT-Databinding example from Saturdays post running on Qooxdoo-GWT.

public class TextLabelBinding extends QooxdooApp {

	@Override
	protected void run(QxAbstractGui application) {
		final QxLabel titleLabel = new QxLabel("");
		final QxTextField firstNameField = new QxTextField("");
		final QxTextField lastNameField = new QxTextField("");

		QxVBox box = new QxVBox();
		box.setSpacing(10);

		QxComposite container = new QxComposite(box);
		container.setPadding(20);

		container.add(titleLabel);
		container.add(firstNameField);
		container.add(lastNameField);

		application.getRoot().add(container, QxOption.left(0), QxOption.top(0));

		final Person p = new Person();
		p.setFirstname("Tom");
		p.setLastname("Schindl");

		DataBindingContext dbc = new DataBindingContext(QxObservables.getRealm());
		QxIWidgetValueProperty uiProp = QxWidgetProperties.text();

		dbc.bindValue(uiProp.observe(firstNameField), UBeansObservables.observeValue(QxObservables.getRealm(), p, Person.FIRST_NAME));
		dbc.bindValue(uiProp.observe(lastNameField), UBeansObservables.observeValue(QxObservables.getRealm(), p, Person.LAST_NAME));

		ComputedValue titleValue = new ComputedValue(QxObservables.getRealm()) {
			private IObservableValue last = UBeansObservables.observeValue(QxObservables.getRealm(), p, Person.LAST_NAME);
			private IObservableValue first = UBeansObservables.observeValue(QxObservables.getRealm(), p, Person.FIRST_NAME);

			@Override
			protected Object calculate() {
				return last.getValue().toString().toUpperCase() + ", " + first.getValue();
			}

		};
		dbc.bindValue(uiProp.observe(titleLabel), titleValue);
	}

}

I’m going to look at the more complex controls when having the next free time slot but for now this is just plain cool, isn’t it?

Andrei Loskutov: On Galileo train

Sun, 28 Jun 2009 21:36:39 +0000

Galileo? Me too :-)

I've just released updates for two of my plugins: Bytecode Outline and Data Hierarchy.

Highlights:

Bytecode Outline learned invokedynamic (JSR 292)
and Data Hierarchy can show data for the base classes too.

Here is a screenshot which may explain Data Hierarchy better then words (check the "UnreadFields" class node). You see here the data hierarchy of the AnalysisContext class:

Doug Schaefer: Understanding the Mobile Killer App

noreply@blogger.com (Doug Schaefer) — Sun, 28 Jun 2009 17:59:38 +0000

Clearly, with the success of iPhone and Blackberry and the buzz around Android and Pre, mobile already has its killer apps. But for someone new like me to this arena, I find it important that I try to understand what that app is and simplify the category so I can know where to focus what little time I have to play here. So this is what I've come up with, and I hope you have an opinion you can share in the comments to help guide me.

Here we go. I actually think there are two killer apps happening in the smartphone market today. (I'll leave out the *book platforms for another post as that's starting to gel in my mind as well). Start by looking at the iPhone, including the iPod Touch. It's really Entertainment apps that have made the iPhone one of the most popular mobile platforms of our time. My son has a Touch. He has his mp3's there, he watches YouTube videos there, he plays games on it. It's probably what the PSP should have been if it had downloadable content. The platform pretty much comes with good multimedia apps, so if you want to make a hit, writing a good game is the place to start. And looking at most of the other platforms, especially the ones with 3D hardware acceleration, this is true across the board. Actually, you look at the real big picture, good games are popular on all computing platforms, even Spacewar! on the PDP-1.

The other killer app is something a we talk lot about in the Eclipse community, especially my enterprise brethren. And that is thin web client apps. This is most obvious on the Blackberries that almost all business managers have today. Accessing e-mail from an exchange server on a small screen requires specialized software to ensure a good user experience. But I really think it goes beyond just e-mail. There are a lot of web services available in web browsers today. But web browsing on the small screen still sucks and likely will always suck. Writing a thin client that can present information from the web in a format suitable for the form factor is a real winner. The top Android apps I use are clients for gmail, twitter, and RSS. I'd love a good app that lets me write this blog, but I haven't found one yet. But I know the Google provides the API to do it and Twitter has a good API. Wrap those together and you got a customer. Or maybe I should be the developer ;).

Of course, now I'm torn. I've always dreamed of making games, but never had the opportunity to do it. I know it's a lot of work and probably something I couldn't do well in my spare time. I'm also pumped by the "mash-up" possibilities writing thin clients for internet apps. And that's probably something I can do more quickly. Lots of fun. And a reason why I think the industry is going through a reinvigoration. Where the killer app for the desktop has come and the shine has gone (that killer app was office apps, browsers, IDEs, and games by the way). There's an opportunity to get in on the ground floor of the new generation.

Robert Konigsberg: Lies, Damned Lies, and Eclipse Upload Statistics

noreply@blogger.com (Robert Konigsberg) — Sun, 28 Jun 2009 03:55:21 +0000

Update: Added 4th assumption, Saturday, June 27

As promised, 48 hours ago I downloaded several Eclipse products across all five published platforms using Bittorrent. Now that two days have passed, and my downloads have been made available for others to upload, I thought I'd consolidate upload bittorrent upload data for the sake of gauging popularity.

Some notes on my bittorrent process:

I downloaded the torrent files at about 10:30pm, two nights ago. I collected the data at about 11:30pm tonight. I'm calling it 48 hours. Anyone who cares enough, call the data police.
I did nothing to cap bandwidth for any of these Eclipse distributions.

I collected data on both megabytes uploaded from my bittorrent client, as well as ratio of upload to download. Since all copies of my products were fully downloaded, an upload ratio of 2.5 means that virtually 2.5 copies of that distribution were uploaded from my machine. Of course bittorrent doesn't ship data in full files, it's just pieces of the distrubutions, here and there.

These are my three primary, and therefore, potentially disputable, assumptions:

More popular products will be uploaded by more people.
Upload ratios are a better measurement of popularity than megabytes uploaded. If product X is 50% larger than the size of product Y, equal bandwidth dedicated X and Y do not denote equal popularity. I just think people using bittorrent aren't really worried about the size of their Eclipse.

Similarly, I consider negligible any difference in compression ratios between the win32 zip file format and other gzipped tar files.

48 hours of data collection is more than enough time to collect data, and taking more than the first 48-hours of data will not yield significantly different results.

I presume that files that are not as well seeded as others will take more time to initially download, and as such, will not contribute much to the other uploads during the first part of this process, and so may exaggerate the results slightly. Given that, I suspect the correctness of the 48-hour window will be the most disputed assumption.

Update: fourth assumption: People don't care about how long it takes, if they're using bittorrent. I assume it's a "set and forget" type of tool.

In retrospect, this turned out some really cool data. I'm very sorry now that I did not download all distributions. This analysis suddenly suffers from its absence.

Let's start with downloads by product:

Here, the clear winner is the JEE distribution. Modeling, which is heavily discussed on the modeling blog and had a crazy number of talks at EclipseCon, has just under 25% the popularity of JEE. I haven't used WTP in a while but I hope, if it's this popular, that the developer docs reflect the popularity. (Please?)

Next we move to downloads by operating system:

Wow, Windows, huh? That's a surprise, and also, not really a surprise. I'd love to see how these numbers compare next year. Will we see an complete inversion of Linux 32 and Linux 64 in a year? Two years? I predict four years.

Let's look at all the download ratio data without grouping by products or operating system.

This chart really highlights both the JEE and Win32 popularity. I'm pleased to see the CDT platform is well used by the Linux32 community. I wonder why, on the Classic platform, OSX Carbon is uploaded slightly more than OSX Cocoa? Are variances on that scale negligible?

I hear the Linux community say "Rob, come on. We just shut down the spin machine from that ludicrous browser comparison. How about something that reflects reality?" Reality, whatever. You punks are lucky drawing charts is fun, so I'll do one more for ya. Here's the same data, with OSX and Linux products as single pieces of data.

Seriously, this does have something more interesting to say:

RCP is more popular among the OSX and Linux communities than Win32.
Without JEE, Win32 is not nearly as popular a platform.
CDT and modeling are not particularly popular among the OSX community.
CDT is loved by the Linux users.

I mentioned earlier that downloads by megabyte are not interesting to me. That doesn't stop me from graphing it. Here's a chart:

and heck, here's another:

Do these last two charts tell you anything different from the download ratio charts? I'll leave that up to someone else to discover. Add it in the comments.

Here's the last three pieces of data I want to share tonight:

Total Uploads: 145
Total MB uploaded: 18,781.1 MB
Upload average (assuming 48 hours): 111.295 kbps

You could say, then, that 145 people got their instance of Eclipse from my bittorrent client.

Thank you, Verizon FIOS. Thank you, Eclipse Foundation!

Tom Schindl: Eclipse-Databinding 3.5 for GWT

Sat, 27 Jun 2009 21:49:14 +0000

I’m a big fan of GWT but one of the real pain points when developing GWT applications is that there’s no databinding framework [*] available to synchronize your domain objects and UI-Widgets.

As many of you know I’m an even bigger fan of Eclipse-Databinding because it is written so that it can be used with ANY Model-Technology you want and even more important ANY UI-Technology you want and in fairly every environment you want (or at least porting to it is possible without too much trouble).

I’m happy to announce that the days without a databinding solution are gone forever now because yesterday in the night I made Eclipse-Databinding 3.5 compile under GWT and already wrote the first WidgetProperty implementations for Text and Label-Widgets.

Take a look at this video to see it in action

The code used to create this small presentation looks like this:

import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.observable.value.ComputedValue;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.ufacekit.core.ubean.databinding.observables.UBeansObservables;
import org.eclipse.ufacekit.ui.gwt.databinding.GWTObservables;
import org.eclipse.ufacekit.ui.gwt.databinding.IWidgetValueProperty;
import org.eclipse.ufacekit.ui.gwt.databinding.WidgetProperties;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.TextBox;

/**
 * Entry point classes define <code>onModuleLoad()</code>.
 */
public class GWTDatabindingExample implements
		EntryPoint {
  /**
    * This is the entry point method.
    */
  public void onModuleLoad() {
    final Label titleLabel = new Label();
    final TextBox firstNameField = new TextBox();
    final TextBox lastNameField = new TextBox();

    final Person p = new Person();
    p.setFirstname("Tom");
    p.setLastname("Schindl");

    DataBindingContext dbc = new DataBindingContext(
      GWTObservables.getRealm()
    );
    IWidgetValueProperty uiProp = WidgetProperties.text();

    dbc.bindValue(
      uiProp.observe(firstNameField),
      UBeansObservables.observeValue(
        GWTObservables.getRealm(), p, Person.FIRST_NAME
      )
    );

    dbc.bindValue(
      uiProp.observe(lastNameField),
      UBeansObservables.observeValue(
        GWTObservables.getRealm(), p, Person.LAST_NAME
      )
    );

    ComputedValue titleValue =
      new ComputedValue(GWTObservables.getRealm()) {
        private IObservableValue last =
          UBeansObservables.observeValue(
            GWTObservables.getRealm(), p, Person.LAST_NAME
        );

       private IObservableValue first =
         UBeansObservables.observeValue(
           GWTObservables.getRealm(), p, Person.FIRST_NAME
       );

      @Override
      protected Object calculate() {
        return last.getValue().toString().toUpperCase()
          + ", " + first.getValue()
        ;
      }
    };

    dbc.bindValue(uiProp.observe(titleLabel), titleValue);

    RootPanel.get("titleContainer").add(titleLabel);
    RootPanel.get("firstNameFieldContainer").add(
      firstNameField
    );
    RootPanel.get("lastNameFieldContainer").add(
      lastNameField
    );
  }
}

If you take a close look to the sources above the first thing you’ll spot is the usage of org.eclipse.ufacekit.core.ubean which is very light weight domain model implementation part of UFaceKit. The domain model has it’s own notification concept and a reflective API similar to EMF but is as light weight as possible.

A domain object implementation looks like this:

import org.eclipse.ufacekit.core.ubean.UBaseBean;
import org.eclipse.ufacekit.core.ubean.notify.Notification;

public class Person extends UBaseBean {
  public static final int FIRST_NAME = 1;
  public static final int LAST_NAME = 2;

  private String lastname;
  private String firstname;

  public void add(int featureId, Object value) {
    throw new IllegalArgumentException(
      "No multi feature with id '"+featureId+"'"
    );
  }

  @SuppressWarnings("unchecked")
  public <V> V get(int featureId) {
    if (featureId == FIRST_NAME) {
      return (V) getFirstname();
    } else if (featureId == LAST_NAME) {
      return (V) getLastname();
    }
    throw new IllegalArgumentException(
      "No feature with id '"+featureId+"'"
    );
  }

  public void remove(int featureId, Object value) {
    throw new IllegalArgumentException(
      "No multi feature with id '"+featureId+"'"
    );
  }

  public void set(int featureId, Object value) {
    if( featureId == FIRST_NAME ) {
      setFirstname((String) value);
    } else if( featureId == LAST_NAME ) {
      setLastname((String) value);
    } else {
      throw new IllegalArgumentException(
        "No feature with id '"+featureId+"'"
      );
    }
  }

  public String getLastname() {
    return lastname;
  }

  public void setLastname(String lastname) {
    notifyListeners(
      new Notification(
        this,
        Notification.SET,
        LAST_NAME,
        this.lastname,
        this.lastname = lastname
      )
    );
  }

  public String getFirstname() {
    return firstname;
  }

  public void setFirstname(String firstname) {
    notifyListeners(
      new Notification(
        this,
        Notification.SET, FIRST_NAME,
        this.firstname,
        this.firstname = firstname
      )
    );
  }
}

The reflective API has the advantage that it doesn’t need reflection to call methods and thus is directly usable within GWT applications where no reflection is available. This is only the start of the many things UFaceKit is going to provide to you starting from full GWT-Databinding support over JFace-Viewer like implemenations to it’s highlevel UI-Abstraction.

For UFaceKit the support of GWT marks a new milestone because now we have a solution for another Java-Developer Community. We now support:

SWT/JFace – including a Java5 JFace-Viewer implementation
Qt – Qt-Databinding and Qt-JFace-Viewers
Swing – Swing-Databinding and Swing-Viewers (though this needs some TLC)
GWT – GWT-Databinding and start of GWT-Viewers (Combo, List and Tree)
UBean – a very lightweight model technology compatible with GWT

The sources are available from the UFaceKit-repository (you need to have the Google-Eclipse-Plugin installed) and an Eclipse 3.5 as the target (if you don’t want to see compile errors in your IDE)

* Update there are databinding-frameworks (GXT, gwittir) but they force me to buy into their whole framework and even reach out into my Domain-Model if I understood them appropiately.

Madhu Samuel: Kudos to the Eclipse Galileo Developers!

noreply@blogger.com (Madhu) — Sat, 27 Jun 2009 07:46:09 +0000

When 40% of all the commercial projects are failing due to one or the other reasons, the technique and style of the eclipse developers have successfully delivered one more annual release of Eclipse Galileo. This is one of the modern wonders. Nothing more than a set of 'strong minds' are required for this kind of achievement.

Any great idea can be spoiled by a careless mind. The same way, any small idea can be turned to a master piece by a great mind. The story of two magicians which wouldn't bring much excitement, when it got into the hands of a director like Christopher Nolan; it turned out to be one of my favourite movie and greatest hits. If you haven't watched the movie 'The Prestige', I urge you to watch it as soon as possible.

The enthusiasm and vibrancy of the hundreds of minds in the Eclipse community, the electric current generated by their thoughts; these are still attracting lot of new people to the community. Framework projects, RnD projects, graphical projecs, modelling projects, bio projects ....

There were many arguments last year. The complexity of some of the frameworks, the simplicity of some of the tools; the anger towards some of the eclipse processes; the sadness when the expected features had to be dropped out of the final delivery, the happiness when the customer/end user said '"See this new feature, Wow'".

Lot of emotions and lot of memories. The emotions which starts in the brain of a single person, when backed by the support of a highly motivated community results in successes similar to what happens in our Eclipse community.

Open source is not a charity always. Hundreds of businesses are thriving upon the open source model. When one of the basic values of humans is followed, ie, 'give and then take'; it results in success and content feeling. When we are following our values, when we are backed by a community with the same set of values, we are at our best.

Many team members were flexing their brain muscles for a long time. Then one of them said on 24th of June, "Guys, we are done for the year"; Its time to relax and celebrate now. Some celebrate the success over a cup of coffee, some over the dance floor and some with a vacation trip.

Life goes on; Eclipse goes on; Next year e4 is one of the most anticipated outputs from the community.

I dedicate this blog to all those gurus who developed the basic eclipse framework and donated it to the open source community; to those who still develop new frameworks in the open source; You people dared to go to the wild, never knowing the dangers behind the hidden rocks and trees, you cleared the path for the rest of us.

I like to convey my gratitude to the hardwork of the hundreds of developers who has worked towards the success of galileo, "Dudes, you all have done a great job. You guys are making our jobs easier".

How can this kind of success be repeated in the high percentage of failing commericial projects?

You need to think out of the bondaries of your organizations, you need to come out of your conventional thoughts, you need to use your brain for what it is designed. "Share" and put some thought behind it, you will start to get the returns. As Robert C Martin says, don't sprint, run the marathon. When your muscles get tired and gets deprived of energy, its your mind which needs to give strength. If the mind losses focus, then the body will fail, our actions become meaningless and the projects fail.

Focus on what you need to achieve. Put your mind and body for it. The results will follow. Its all a mind game. You are a reflection of your mind!

madhu

Erkki Lindpere: P2 Still Not Awesome

Fri, 26 Jun 2009 19:57:11 +0000

P2 has surely seen a lot of improvement in Eclipse 3.5, but some functionality that was actually somewhat acceptable in the old Update Manager is still lacking awesomeness. I’m trying to install VE into Galileo (Eclipse for Java + M2Eclipse + Subclipse + Scala IDE).

There are two usability issues with this. The first is that after selecting the “Visual Editor” feature from the site, I don’t have a “select dependencies” option. But from past usage of VE I remember that it requires Java EMF Model. So I select that too. A new user would not know to select this. I’ll have to navigate to the next page to find out if there are unresolved dependencies. And then we come to the second problem, which is this screen:

Am I really supposed to decipher this text and take action based on that? No thanks, I’ll just skip installing VE this time, I don’t have actual need for it right now.

Gabe O'Brien: Everywhere a Tweet Tweet..

noreply@blogger.com (Darn Good Developer) — Fri, 26 Jun 2009 18:26:13 +0000

Not to be left behind in the buzz surrounding Twitter, the Submissions System now tweets when a new talk is proposed. There are already three talks proposed on the Summit twitter page, new follower are always welcome.

Not planning on presenting a talk at Eclipse Summit but still want to try out the tweets? Then cruise on over to the demo conference and propose a new talk. The demo conference exists just to try out new features. The Demo conference twitter page already has one follower (not sure how that happend).

Birt World: Passing JDBC ResultSet to a report

noreply@blogger.com (Scott Rosenbaum) — Fri, 26 Jun 2009 16:56:01 +0000

Nice article on how to pass a JDBC resultset to a report at

Techie.Ocean

Yves Yang: Eclipse VE gets revived!

Fri, 26 Jun 2009 15:35:08 +0000

I’m pleased to announce the come-back of VE in Eclipse stream after more than two years’ sleeping. Now the builds for eclipse 3.4 and 3.5 are available here:
http://www.eclipse.org/vep/downloads/

The VE home page gets updated as well.

I’d like to thank Nick Boldt who had done an excellent job to re-integrate VE into eclipse build system and update the Web page.

Now, it is time to consider new features and the development plan for the next release 1.5. Please use ve-dev@eclipse.org to send us your feedback and requests.

Denis & Karl: Galileo should go down …

Fri, 26 Jun 2009 15:16:34 +0000

… as being the smoothest release I have ever participated in, despite the major constraint I had this year: no extra bandwidth shall be purchased.

Here is how we pulled this off:

1. More bandwidth. Since we got sooo many new Friends of Eclipse, I bent the rules and added 12 megabits of bandwidth [1]. But — get this — for the pre-release only. Marker (1) shows the increase, and marker (2) shows a significant drop three hours into the release. Unheard of!

2. Early access. Friends of Eclipse, mirror sites and Member companies all had early access to the bits, relieving some of the stress on release day.

3. BitTorrent. In April, I didn’t have options (4) and (5) below, so with the no-extra-bandwidth rule, I had to set up something. Actually, I suspect many Friends took advantage of their benefits by downloading and pre-seeding many of the files before release day. More seeds == faster downloads.

4. Eclipse Member companies. They provided lots of bandwidth (and still are!) via the Get It Faster section of the download page. Many thanks!

5. Amazon Web Services. This was a last-minute deal that was/is a true blessing, since I was able to redirect lots of the download.eclipse.org requests to AWS instead of our stressed mirror sites.

6. Server virtualization. Our own version of ‘the Cloud on demand’ — I enabled an extra virtual server node for www.eclipse.org on June 23 to handle the extra CPU power that would be required to handle the many requests. I may just shut it off later next week, or I may just keep it around…

I think we’re getting good at these annual release trains..

[1] In reality, we get billed by the 95th percentile, so if I played my cards right, the extra bandwidth may end up costing us next to nothing.

Neil Bartlett: Calling all DSL Nuts and Scaliens in London

Fri, 26 Jun 2009 14:45:46 +0000

Are you interested in Domain Specific Languages (DSLs), Scala, finance or JavaFX? Are you in or near London?

On Monday 29th June, SkillsMatter will be hosting the third Eclipse DemoCamp to be held in London. DemoCamps are fun, informal events for Eclipse developers and users to talk about what they are working on, with a strong focus on working demos and real life applications. This time we have a number of very exciting speakers:

Heiko Behrens will be demoing Xtext. This is an amazing tool for building DSLs — it allows you to define a simple grammar in EBNF notation, and from this it will generate a parser, Abstract Syntax Tree (AST) meta-model, and a fully-featured Eclipse editor with auto-completion, syntax highlighting, content outline, hyperlink navigation.
Miles Sabin will show his work on the Scala IDE for Eclipse. Many people (including me) believe that Scala will be the next big language for the JVM, and it’s important to have tooling for it that is just as good as the tooling available for Java. Miles is doing a great job in making that a reality.
Richard Gomes will be talking about JQuantLib, an open source library for quantitative financial calculations in Java. Richard has been working on integrating JQuantLib with OSGi and (hopefully!) contributing it to the Eclipse Finance Platform project, and he will talk about the benefits and challenges involved.
Dan Pollitt will demo NatTable, a high performance SWT data grid control that can be used to display huge quantities of rapidly changing data, and is used by a number of banks for trading applications.
I will demo the JavaFX plug-in for Eclipse, which I have been working on for Sun Microsystems.

Full details and registration instructions are on the Eclipse Wiki site. Hope to see you there!

Michael Spector: Some (low quality) pics from Tel Aviv Eclipse Demo Camp

noreply@blogger.com (Michael) — Fri, 26 Jun 2009 12:34:21 +0000

Prakash G.R.: Keyboard accessibility thru Command Framework

noreply@blogger.com (Prakash G.R.) — Fri, 26 Jun 2009 07:40:41 +0000

Keyboard shortcuts is usually much speedier than reaching out your mouse, moving it, pointing it to something and clicking. But there are some things which cannot be done that easily by keyboard shortcuts. For me, one of them is finding out a closed project and open it. Unfortunately, I've quite a large set of projects in my workspace and try to keep most them closed, when not used. In addition to that in the Package Explorer, I've the 'Closed Projects' filter on. So if I need to open a project, I've use the pull down menu, uncheck 'Closed Projects' navigate thru the working sets to find the right project and double click it. To enable keyboard access to this regular task, I decided to make use of Commands Framework.

The solution is to add a parameterized command, and in the values, I compute the projects which are closed. So when I press the awesome shortcut (Ctrl+3) it would display me the list of closed projects. With few keys, I can navigate to the project I want and open it. Lets see how to do it. First step is the command with the parameter:

<extension point="org.eclipse.ui.commands">
   <command
            defaultHandler="com.eclipse_tips.handlers.OpenProjectHandler"
            id="com.eclipse-tips.openProject.command"
            name="Open Project">
      <commandParameter
               id="com.eclipse-tips.openProject.projectNameParameter"
               name="Name"
               optional="false"
               values="com.eclipse_tips.handlers.ProjectNameParameterValues">
      </commandParameter>
   </command>
</extension>

And the handler:

public Object execute(ExecutionEvent event) throws ExecutionException {
 String projectName = event.getParameter("com.eclipse-tips.openProject.projectNameParameter");
 IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
 IProject project = root.getProject(projectName);
 try {
  project.open(null);
 } catch (CoreException e) {
  throw new ExecutionException("Error occured while open project", e);
 }
 return null;
}

For the parameter values, I look for closed projects and return them:

public Map<String, String> getParameterValues() {

 IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
 IProject[] projects = root.getProjects();
 Map<String, String> paramValues = new HashMap<String, String>();
 for (IProject project : projects) {
  if (project.exists() && !project.isOpen()) {
   paramValues.put(project.getName(), project.getName());
  }

 }
 return paramValues;
}

So finally, When I press Ctrl+3 and type OPN, I get the list:

This idea can be extended to provide keyboard accessibility to many functionalities. Say in an RCP mail application, you can add a command like 'Go To Mail' with parameter as the Subject/Sender:

Hmmm, if only the 'Built On Eclipse' mail app that I *have* to use, knows the existence of threads other than the UI thread :-(

Peter Kriens: Hi, We're OSGi. We mean no harm

noreply@blogger.com (Peter Kriens) — Fri, 26 Jun 2009 07:26:55 +0000

Dear James,
I read your interesting interview with eWeek. There were many parts where we agreed, but I was also slightly puzzled with your observations about OSGi. "OSGi is this thing that kind of came from a different universe that's being used for modularity." I do agree that many people see the quality of the OSGi specs as out this world, but that seems a bit exagerated. I do agree we did not start out in the enterprise application space, we started in embedded world where space and performance constraints are pervasive, but after all I thought we both lived in the Java universe. However, this seems at odds with your remarks like "So we needed something that was a lot lighter weight." and "... OSGi's just too much fat."

Hmm, the OSGi core API is 27 classes. That is a all. Security, Module layer, Life cycle layer, and Service Layer. Exceptions, permissions, and interfaces. And one of them is even deprecated! Just the module layer in Jigsaw seems to have more classes, and they just got started ... Or did you mean the implementations? With Concierge at around 80k for an R3 implementation and Felix at 350k it seems a stretch to call us fat? OSGi is even deployed in smart cards.

It's true, our documentation is a bit fat. The core is described in 300 pages. Though we have lots of pictures! And we have virtually no errata, despite the fact that OSGi has been used in tens of thousands of applications over the last decade.

I'd like to tell you a little anecdote. In 1997 I tried to convince Ralph Johnson about Java. My key argument was that Java was so nicely small and therefore easy to understand. Only 11 packages! Ralph, a famous Smalltalker, looked at me wearily and said: "Just wait." Oh boy, was he right. That lesson still drives me every day to keep OSGi lean and mean, annoying many people along the way, but I guess that is the price one needs to pay.

If you think project Jigsaw will be leaner than OSGi, well, modularity is a problem where size does matter. You cannot demonstrate modularity with a Hello World because modularity solves the problem of large evolving code bases. [deleted]

So, James, I think that are lots of details where we did not get it perfect, but OSGi's weight is not one of them. The misconceptions about OSGi at Sun stand to cost our industry a lot of money and pain in the coming years. Project Jigsaw's simplicity is a fallacy, hidden by the fact that they do not address the hard issues that OSGi has now been working on for over a decade. All major application servers are today based on OSGi, not because it was fun or a hype, but because they had no choice. These are applications in themselves that have a scale where modularity is not an option but a necessity. The success of open source will move many Enterprise applications in this same realm.

If you believe that a simplistic solution can address the needed scale, well than indeed we do live in another universe. However, please remember that we're here as friends, to help, and mean no harm.

Your's sincerely,

Peter Kriens

Doug Schaefer: Android NDK Release 1 is Out

noreply@blogger.com (Doug Schaefer) — Fri, 26 Jun 2009 03:39:56 +0000

I got a surprise today (aside from the passing of Michael Jackson), the Android Native Development Kit (NDK) team has put out its first release. They never really hinted on their mailing list this was about to happen, nor did they actually provide a real time line. But it's a good surprise.

The purpose of the NDK is to provide the ability to write native libraries that the Dalvik Java code can call through the Java Native Interface (JNI). This is the exact same interface we're used to with desktop JNI so it's quick to use. As I've mentioned here before, writing native code allows you to take advantage of the underlying hardware that Java hides from you. In this first release, it's pretty basic, exposing only a few basic APIs such as the standard libc C run-time library, the math library, and libz for accessing compressed files. Just enough to accelerate some of your algorithms with direct execution by the CPU, which is ARM only right now.

There is still a lot missing, and they have promised there is more to come. OpenGL ES and audio are the big items on my wish list. At least I have enough information to be able to set up OpenGL ES so that it'll run on my HTC Dream phone and the emulator. But there are no guarantees it will run on any of the upcoming phones since the ABI hasn't been locked down. The GLES shared library name is the biggy (e.g. PowerVR as seen on the TI OMAP chips names their libs differently) although the header files should be the same.

The build system, though, has me very concerned. They've taken a lot of the concepts from the Android platform build system, which builds everything in one tree, and brought it to the NDK, including the restriction that everything has to be in one tree. I don't build software like that. I put my native code in the same Eclipse project directory as the Java. I'm also working on a library that I want to use in a number of different platforms as mentioned in my previous entry. Android is just one target, it's not the center of the universe.

I also noticed this when I took a look at Moblin. There is a standard way you setup a gcc cross-development environment. GCC has the facility to define a sysroot that organizes include files, and libraries in a natural way. And that allows for multi-target projects with very little change to your makefiles. Don't assume you're the only build system that wants to build my code.

One final nit, the Windows toolchain was built using Cygwin. Cygwin is a Linux emulation environment for Windows. As such it tries to hide as much of the Windows environment as it can, in particular when dealing with file paths. That messes up the CDT. We have some code that tries to deal with that, but the architecture is poor and we may loose that functionality over time. I'm a big fan of CodeSourcery and these guys are masters at building toolchains for multiple targets and run cleanly on Windows without Cygwin. Mind you, I'm pretty much solely on Linux now so that doesn't matter to me as much any more. But others in the community will care.

Anyway, besides all that, it's a great start. Native development and standard native APIs will be a key success factor for Android. We saw in the game console market how important it was for game developers to be able to target multiple platforms. That larger market allows for larger budgets which, of course, allows for better apps. The Apple guys get that and the iPhone SDK is very good, and at least for 3D Graphics and Audio, very standard. John Carmack of id (Doom and Quake) is a huge fan of theirs, but I wouldn't mind seeing Doom titles running on my Android phone.

Remy Suen: Native widgets? Check. Native icons? Maybe not…

Fri, 26 Jun 2009 01:58:48 +0000

Eclipse-based applications looks and feels native thanks to SWT but once you start gandering at them icons, it just doesn’t quite hit the mark. For the readers out there that are familiar with the Tango Desktop Project, the window below doesn’t look out of place at all, right?

In the Eclipse world, the icons don’t really bother us at all since we’ve been looking at them for so many years. Unsurprisingly, for some clients and users, this doesn’t quite cut it and they want to customize them a little or they want the icons to match their own desktop’s. What if you could appease these people by adding a little ‘Theme’ menu at the top to flip around some options? Or what if the user could just define their own icon preferences…?

If you’ve ever been troubled by icons like the two bug reporters above, e4 CSS support could be the solution to your problems. Feel free to comment on bug 281593 if this piques your interest. You can help shape e4 into the next generation platform that you and your clients need! Join the e4 team, today! :)

Note: I realize that in the Eclipse world we have very specific user interface and icon design guidelines so this may not be everybody’s cup of tea. But hey, if you’re not interested in this, feel free to work on something else! Let me tell you, there’s no shortage of work in the e4 project. ;)