Turns out using AppleScript to launch applications is fairly easy, all you have to do is

tell application "name of your app" to launch

If you want to try this from the command line, osascript comes in handy:

osascript -e 'tell app "iTunes" to launch'

So far so good. Should be easy to do this from Java, shouldn't it? Turns out it's not so easy at all. Let's try this:

  String launchCmd = "osascript -e 'tell application \"iTunes\" to play'";
  process = Runtime.getRuntime().exec(launchCmd);

  BufferedReader bufferedReader = new BufferedReader(
    new InputStreamReader(process.getErrorStream()));
  while ((lsString = bufferedReader.readLine()) != null) {
    System.out.println(lsString);
  }

I'm not sure why, but it results in a nasty "0:1: syntax error: A unknown token can't go here. (-2740)" error message.

But there is another signature for Runtime.exec:

  String[] cmd = { "osascript", "-e",	"tell app \"iPhone Simulator\" to launch" };
  process = Runtime.getRuntime().exec(cmd);

  BufferedReader bufferedReader = new BufferedReader(
    new InputStreamReader(process.getErrorStream()));
  while ((lsString = bufferedReader.readLine()) != null) {
    System.out.println(lsString);
  }

... and this works out just fine!

Thanks for reading this post. You should follow me on twitter here

Before I give some reasons why I use Twitter, let's have a look at some stats.

I sent out roughly 2660 tweets, on average 8.4 per day:

Looking at my tweet density, I hardly seem to be getting any sleep, which is not entirely true

Over the last year, I tried quite a few twitter clients, but I like Tweetie the most (yes, I'm using a Mac):

Why I use Twitter

• Twitter helps me to keep informed about topics I am interested in, while at the same time giving me the chance to get in touch with the sources of that information and give feedback.
• Many vendors and dev teams have Twitter accounts and use them to twitter about what they're currently doing / developing, again helping me to keep up-to-date about current developments
• Twitter helps me to "hear" what others are saying about the tools I and my teammates develop. Twitter clients like TweetDeck and Nambu allow you to define custom searches. E.g., I've got a search defined for "Xtext OR DSLs" so I will be informed each time someone tweets about either Xtext or DSLs. This allows me to give instant feedback to users needing help or ranting about Xtext (actually, most users praise Xtext, so I'm mostly using this search to retweet that praise)
• Twitter is like a big room in which everybody can hear what you're saying. You can use this fact to use Twitter as a marketing channel, and that's what we do with Xtext, too. We get the word out on Xtext, e.g. by announcing cool new features or talks we're giving at upcoming conferences.
• I also use Twitter to get / keep in touch with co-workers, friend and also clients. More often than not when meeting new clients, I hear people say "nice to meet you in person after we have been talking on Twitter". Sometimes, I use Twitter instead of my phone to ping people ("give me a call when you are available") - works great!
• By using Twitter, you will actually feel much closer to your peers ("tweeps") than you did before. This holds true especially for the Eclipse crowd. Many of us follow each other on Twitter and thus know what we do in our day to day job (and in our spare time, too) better than before.

Some recommendations

Whether you're new to Twitter or have been using it for years, here is my list of recommendations for Twitter. May it be inspirational for you:

• Find a decent client. The web interface is O.K., but in order to use all the power of Twitter, you need to use a real client. My main work horse is Tweetie (on the Mac), mostly because it allows me to view conversations in a really neat manner. On the iPhone I recommend TweetDeck - you can easily define additional columns to display custom searches, DMs, tweets nearby and so on. Nambu also is very nice - and native! TweetDeck on the Mac is also great, but eats a lot of resources, which is why I rarely use it any more. If you want to issue tweets without losing context, give Google Quick Search Bar a try - there's a plug-in that allows you to tweet from QSB.
• Do NOT protect your updates. After all, you want to get in touch with other people. So there really is no point in protecting your updates.
• If you're new to Twitter, make sure to post some tweets before starting to follow other people. You want to make sure other people are following you too, but why should they follow you if you've got nothing to say?
• We're not interested in disgusting details about you, your family or your friends, so keep them for you.
• I follow people mostly for professional reasons. Tweeting personal stuff is perfectly OK and can add that grain of salt which makes you human, but you should try to keep a balance.

Summing up

Summing up all things, using Twitter has helped me to get in touch with a huge amount of people I wouldn't have interacted with if I hadn't been using Twitter.

If you read all this, let me lift the secret about the obviously wrong mathematical equation in the title of this post: it's the number of characters you may use for one tweet (140), the number of days since I started using Twitter and the total number of tweets I sent out (2659). Actually, as I am using Twitter Tools for Wordpress, this blog post will automatically be announced on Twitter and thus be tweet number 2660.

Thanks for reading this post. You should follow me on twitter here

The program was packed with interesting talks and we were lucky to be able to present some very well known speakers:

1. Tom Schindl: E4 - A short overview
2. Jan Köhnlein: Combining graphics and text in model editors
3. Jochen Krause: RAP
4. Nils Hartmann, Gerd Wütherich: Fifty ways to build your bundle...
5. ekke (Ekkehard Gentz):redView - dynamic views for business applications

If you were not lucky enough to attend the DemoCamp, here is a short summary of the sessions:

e4 - modeling meets runtime (Jochen Krause on behalf of Tom Schindl)

Tom Schindl couldn't attend the DemoCamp due to heavy snow in Innsbruck (the airport was short of planes to fly out, actually). After a short vcon with Tom, Jochen Krause held the e4 demo on Tom's behalf.

e4 has three principal aims:

1. simplifying the Eclipse programming model
2. enabling the platform for use on emerging web-based runtime technologies
3. and broadening participation in development of the platform

One of the measures to make programming Eclipse easier is to define a list of core services and make sure they have a really decent API. This list of services is called "The 20 Things" (see the Eclipse wiki for more information).

You might have heard that EMF is playing an important role in e4 and I think it is one of the most amazing things about e4 that the entire workbench is modeled, of course using EMF. Actually, you can change the workbench at runtime by just modifying the underlying model at runtime. I think it is very exciting to see modeling and runtime technologies converge in this project.

e4 also makes massive use of dependency injection, which allows for a flat object model (Instead of providing a subclass for every special feature, you can just inject other classes providing that particular feature). We had a discussion about dependency injection. Jochen showed that several methods in e4 use String-based dependency injection, which of course leads to several problems. Sven pointed out that this is not a DI problem per se and suggested to use interfaces to alleviate the situation.

Heiko raised the question of whether we should have a dedicated session on dependency injection at one of the next democamps:

Jochen continued his session, explaining how the e4 UI is being rendered by a presentation engine which can be configured using various renderers, each one providing an individual look and feel.

e4 is the future of Eclipse, and Jochen concluded his talk by pointing out that in order to ensure e4 has a sustainable future, companies and individuals should participate in the development of e4. This can be done by:

• Playing around with e4 and providing feedback
• Participating in the development process (see the e4 project homepage for more info)
• Paying existing committers (see Tom's blog posting to learn how to buy one and get one free)

More info on e4 can be found on the Eclipse wiki.

After the talk, we had a short break to set up the next presenter, enjoy some refreshments and, of course, socialize:

Combining graphics and text in model editors (Jan Köhnlein)

After the break, Jan Köhnlein took stage and told the audience that graphics and text and no different, but really are just two views on the same thing:

Jan pointed out that both text and graphics have their relative virtues:

Text...

• provides a detailed view on things
• can have a very formal syntax
• can be typed using standard text editors
• can be managed using standard versioning mechanisms (merge / diff)
• can be typed fast

Graphical representations on the other hand...

• provides high-level views and a good overview
• suggests non-formalism
• requires custom editors for your graphical notation (i.e., you need to write them)
• has no good support for merging / diffing
• requires the user to use a mouse a lot, and thus is slower than a text editor

Apparently, both have advantages, so why not use both?

In the following 5 minutes, Jan gave an ultra-quick introduction in how Xtext (as a representative of a textual modeling toolkit) and GMF (as a representative for a graphical modeling toolkit) work. The bottom line is both use Ecore metamodels, so we should be able to combine both.

It turns out, however, that Xtext and GMF metamodels are slightly different and you need to take some precautious steps in order to make them interoperable.

After this excursion into the theory behind the convergence of graphical and textual editors, Jan showed two editors, one graphical and one textual that synced live. Changing the model in one editor and saving it effected an immediate update in the other editor - really neat.

Jan pointed out that this is all very fine, but sometimes you really want to have a tight integration. As a proof of concept, he showed a GMF-based editor with an embedded Xtext editor: as soon as he pressed F2 to edit a field in the graphical editor, an inline Xtext editor would pop up, featuring syntax highlighting, code completion and error markers - really awesome!

More information on Xtext and GMF can be found on their respective homepages. Jan works for itemis and provides consulting and training for these technologies.

All these exciting things must have made people gasp for air, because the oxygen level in the room was very low at the end of the session, so we had another break. As always with gathering like this, hallway talks very equally important as the sessions, and people made good use of the break:

RAP (Jochen Krause)

Jochen's presented his talk on RAP without a single slide - "in the tradition of the Karlsruhe DemoCamps", as he pointed out.

No technical session without some history and some theory, so Jochen first explained that RAP implements the Half Object Pattern and demoed the very first version of RAP. While running an Eclipse UI in the browser is all very exciting, feedback from initial users wasn't too positive: "please spare us this look'n'feel in the browser!"

So the good people at innoopract (now EclipseSource) spent some time to implement custom styling for RAP UIs, which Jochen showed in his second demo, which he called "The Enterprise Look'n'Feel" due to it's feasibility for enterprise applications.

The third demo featured "rounded corners" (see RAP New & Noteworthy). While this might seem like little gained, Jochen explained that implementing rounded corners was both important on an acceptance level and challenging on the implementation level. Would you have thought that rounded corners are implemented using CSS on FireFox and VML on Internet Explorer?

Of course, RAP is implemented as an Open Source project at Eclipse, welcoming any contribution from users worldwide. Jochen demonstrated how great the Open Source model works by showing off a ribbon-style command bar for RAP which is available on Google Code (see the rapit project home page)

In the next demo, Jochen showed how he integrated EMF and RAP. His goal was to RAPify the EMF tree editor for EMF models. It turned out that basically it is very simple to convert the EMF editor (or any other Eclipse plug-in for that matter) into a RAP application - only very little adjustments were needed. However, as web applications are multi-user applications by definition, additional care has to be taken when converting editors. As Eclipse is a single-user application, editors are not prepared to be executed in a multi-user environment. Jochen explained how he tried to use CDO to store the edited models on a remote server, but failed due to the complexities of CDO. He succeeded by using CouchDB, a database written in Erlang and with an HTTP interface (look ma - no JDBC driver needed!).

Jochen concluded his session with a few notes on features they've just completed (Drag'n'Drop) or which are not available (yet) like GC.paint.

After that, he took some of the audience's questions, e.g. "How many users can a RAP server take?". Of course, it depends, but you can roughly count 1MB per user and workbench.

Jochen thought it would be OK to continue without a break, but Martin decided we should rather have a short break to let in some air.

More information on RAP can be found on the Eclipse wiki and on the project homepage. Jochen's company EclipseSource provides professional services, training and resources around RAP, so have a look at their website.

50 ways to build your bundle (Gerd Wütherich & Nils Hartmann)

After the "short" break, Gerd Wütherich and Nils Hartmann presented their view on build management: "Fifty Ways to Buid Your Bundle":

Facing the fact that nobody seems to be too excited about build management these days, they decided to arrest people's attention by adapting the well-known story "A Christmas Carol" by Charles Dickens. A brilliant idea, which really made people laugh at various points throughout the presentation.

The presentation was subdivided in three parts:

The Ghost of Build Past
Gerd and Nils explained how in the past, people have been building bundes using PDE build, using a Manifest-First-approach. Building bundles with PDE build is rather cumbersome: you have to setup map files in order to help PDE build to derive ANT build files which will then be executed by the AntRunner inside Eclipse. While this ensures the build process sees exactly what Eclipse sees when you develop your bundles in the workspace, this basically makes debugging your build process very complicated.

The Ghost of Build Today
Today, we've got bundles everywhere and OSGi is being used not only for Eclipse plug-ins, but also for conventional applications. As good programers obeying the DRY principle, we want to have a redundancy-free description of our build artifacts, i.e. derive build dependencies by looking at MANIFEST.MF. In the enterprise, things can get really nasty, as we often need to integrate various very different build systems: you might have to build an EJB client JAR (maybe using Maven) which then need to be integrated in an Eclipse RCP client application, which again needs to be built using PDE build.

Nils and Gerd showed a slide which listed all major build tools for bundles, among them:

• Springsource Tool Suite
• PDE
• Athena
• PluginBuilder
• Buckminster
• Tycho
• Maven
• b3
• Ant4Eclipse
• PDE build
• bnd
• Ivy
• Buildr
• IDEA
• Sigil
• buildr4osgi
• OsgiPlugin
• ANT
• Bundlr

After which they showed three exemplary setups how to actually build bundles:

1. ANT4Eclipse
2. Maven Tycho
3. Buckminster

Please refer to their slide deck, slides 14 - 16 for detailed diagrams on these three setups:

Ghost of Build Future
As things get more complicated, build management will also most likely become more complicated. Gerd and Nils pointed out that build management might be an unthankful job, but it must not be assigned to "people that aren't good at programming". Instead, they advocated making build management a first class citizen in computer sciences education.

More information on the tools and techniques presented are available at their respective home pages. In addition, you can contact Nils and Gerd and bug them with your questions. They're consultants, so they can be hired.

redView - dynamic views for business applications

The final session was held by Ekkehard Gentz, better known as ekke. He showed a smart combination of Eclipse technologies: Riena, EMF, openArchitectureWare (Xpand, Xtend, MWE) and Xtext. Of course, being an Open Source advocate, Ekke and his team mate Florian provide this stack as an Open Source project on Google Code.

redView is a declarative framework based on the Eclipse Modeling Framework (EMF), for creating RCP Views enriched with Riena Ridgets. It uses EMF to describe the application with a model. An Xpand-based code generator will then transform the model into code for the application. Ekke states that their goal is not to limit developers' creativity, but instead relieve them from the burden of having to write all the boilerplate code.

redView supports the most important UI elements, including some Nebula widgets. One thing I fond very impressive was their UI editor. Ekke gave a demo in which he hosted the UI model on a CDO (which seems to be Eclipse's wunderkind) server on a virtual machine. He started a second virtual machine, running an instance of the application. Upon changing the UI model in the UI designer on one machine, the UI was updated immediately on the second machine. Ekke pointed out that this usage pattern is especially useful in prototyping scenarios: the developer changes the model on his PC in his office and the customer can immediately see the changes on his machine, hundreds of kilometers away.

More information on redView can be obtained from their project homepage. Ekkehard is a freelance consultant, so you can hire him if you've got any questions regarding the technologies presented.

Gimmicks

After the demos, we raffled off 20 Eclipse Keybinding Mugs (see Kim Moir's blog post for a 360° shot of the mug) - congratulations to all winners! it-agile also provided a fine selection of agile swag: retrospective mugs, team calendars, post-its and what have you:

Despite the fact Ralph Müller couldn't attend the event, we eventually headed to the EAST bar for some frosty beverages.

All in all, it has been a very enjoyable event and from what I gathered, most attendees seem to have enjoyed the DemoCamp as well.

Thanks everyone for attending! Also, thank you to all speakers. Last but not least a big thank you to Natalia for taking pictures of the event!

Hope to see you again at the next DemoCamp in Summer 2010!

Thanks for reading this post. You should follow me on twitter here

To alleviate  this situation, I decided to display the "owner" of a verb along with the name of the verb in the content assist drop down box. Here is my first try:

public class StoryDslProposalProvider extends AbstractStoryDslProposalProvider {
  @Override
  protected ICompletionProposal createCompletionProposal(EObject element, String proposal, String displayString, ContentAssistContext contentAssistContext)
  {
    if (element instanceof Verb) {
      Verb verb = (Verb) element;
      Subject owner = ((Subject)verb.eContainer());
      String myDisplayString = verb.getName() + ": " + owner.getName();
      return super.createCompletionProposal(element, proposal, myDisplayString, contentAssistContext);
    }
    return super.createCompletionProposal(element, proposal,  displayString, contentAssistContext);
  }
}

With this piece of code in place, the content assist proposals for verbs will now display the name of the "owner" to the right of the replacement text:

Sebastian pointed out that there is a getDisplayString() in AbstractContentProposalProvider that you should override in order to create a custom display string. It turned out, however, that this method will not be called as expected. I filed a bug, so expect to see a fix in one of the next milestones of the Xtext 0.8.0 stream.

Thanks for reading this post. You should follow me on twitter here

You guessed it, these are not the questions from a well-know Woody Allen movie, but questions that will be answered at the Eclipse Modeling Days which will be held in New York and Toronto in November.

So if you are wondering why everybody in Europe is so thrilled about Modeling, attend to one of these events - you'll get the answers there.

For your convenience, here is a list of some of the talks:

• Case Study: Model Transformations - Richard Woods, Credit Suisse
• Building DSLs with Xtext - Heiko Behrens, itemis
• Modeling on an enterprise scale - Eike Stepper, Eclipse Modeling Project
• Query, Transaction and Validation - Bernd Kolb & Boris Gruschko, both SAP
• Agent-Based Computer Simulation for Operational Risk Analysis - Ed MacKerrow, Los Alamos Labs
• Papyrus: Advent of an Open Source IME - Kenn Hussey, Zeligsoft
• B3: A Model for Unbreakable Builds
• There's a Modeling Solution for That - Bruce Trask, MDE Systems & Angel Roman, MDE Systems

If you ask me, this is a pretty decent line-up, both content-wise and people-wise. Not being one of the big conferences, the Modeling Days will actually give you the chance to talk to the experts and other end-users. Remember, networking is key.

So go ahead and register by adding your name to this wiki page. Registration is free, but you need to register in order to help the organizers to plan the catering. If you don't have an account for editing the wiki page or don't want to create one, just send mail to eclipse_modeling_nyc@eclipse.org or eclipse_modeling_toronto@eclipse.org

Thanks for reading this post. You should follow me on twitter here

propertyA=SomeValue
propertyB=${propertyA}.SomeOtherValue
listofThings=${propertyA}, ${propertyB}, constantValue

Let's further assume you want to read property listofThings, and resolve the variables. Isn't that a perfect job for regular expressions?

Using Regex Tester, I came up with the following regular expression to find occurrence of ${variable}:

\$\{(.+?)\}

Using java.util.regex.Pattern and java.util.regex.Matcher to find all occurrences is rather trivial:

Pattern re = Pattern.compile("\\$\\{(.+?)\\}");
Matcher m = re.matcher(sourcestring);
while (m.find()) {
  String variable = m.group(1);
  System.out.println(variable);
}

Replacing the variables with their concrete values is not so trivial. You might be tempted to use String.substring():

value = sourcestring.substring(0, m.start()) + replacement + (sourcestring.substring(m.end()));

But this will modify the source string, basically throwing the matcher out of the curve.

Looking at the matcher API, I found java.util.regex.Matcher.appendReplacement(StringBuffer, String) and java.util.regex.Matcher.appendTail(StringBuffer). These two little gems to the trick:

private String resolve(String sourcestring, Properties props) {
  Pattern re = Pattern.compile("\\$\\{(.+?)\\}");
  Matcher m = re.matcher(sourcestring);
  StringBuffer result = new StringBuffer();
  while (m.find()) {
    String variable = m.group(1);
    String resolved = resolve(props.getProperty(variable), props);
    m.appendReplacement(result, resolved);
  }
  m.appendTail(result);
  return result.toString();
}

Regular Expressions do save the day!

Thanks for reading this post. You should follow me on twitter here

• Eclipse in the Enterprise: Lessons from Google
• Distributed OSGi
• Deploying Successful Enterprise Tools
• Build and Provision

all dealt with how Eclipse can be used in the Enterprise or which challenges you will face if you start using Eclipse in large-scale scenarios. The talks

• Developing DSLs with Eclipse
• Eclipse in NASA Mission Control
• Build and Provision

either directly had modeling as their topic or used modeling technology to solve their problems. I especially liked the NASA talk which featured a number of computer animated videos of recent or future missions. The NASA mission control software is heavily based on Eclipse and technology form the Eclipse Modeling Project. Finally, there were some talk on runtime technology:

• OSGi for Eclipse Developers
• Developing for Android with Eclipse
• Google Plugin for Eclipse: Not Just for Newbies Any More

Attending great talks of course is one of the major benefits of going to a conference like this. To me, meeting other people and connecting has become even more important than attending great talks. Of course, this is nothing new to event organizers and so there were many chances to grab a drink and chat with the other attendees. With more than 170 people attending, it was hard to have a chat with everyone, but nevertheless I managed to talk to a number of people, many of which already are Xtext users or are now planing to have a detailed look at it. Even Google is using Xtext, but ssshh! Overall, I really enjoyed my two days at Google and look forward to more events like this. Speaking of which, Eclipse Summit Europe is approaching fast, so make sure you register on time. Also, if you're interested in Modeling and DSLs, we're organizing a Modeling / DSL Day in North America this coming fall - see my previous post for more info. And finally, here are the slides and the video of my talk:

Thanks for reading this post. You should follow me on twitter here

http://spreadsheets.google.com/viewform?hl=en&formkey=dF ZQcGh3RDhrUUdyNTAtMXlVU2pKQ1E6MA..

Our goal is to organize an event especially for people new to modeling or who are curious what this modeling fuss is all about and how it can help them. So, this will not be an experts meeting, but you can meet experts talking about their topics. We also are interested in case studies, so ideally you will get first-hand experience from people who use modeling in real life to meet real challenges.

We welcome any feedback, so please fill out our little poll.

Thanks for reading this post. You should follow me on twitter here

Goal

Let's imagine we want to create an application for orders. People can sign in to the system, place orders for various items, check out and have them sent to their address. Very simple, but we can show a lot of things here.

As we expect to be writing more than one application of this type and as we also would like to be able to express the structure of the application on a business level (one of the major drivers for DSLs and MDSD for that matter), we come up with the idea of using a DSL to describe what the application does. Defining the DSL is what we did last week. This week, we need to map the concepts of the DSL to some code and some APIs we're going to program against.

So, we're going to create a set of code templates for a code generator that can then read our DSL models and create persistence code for us.

Prepare

In order to draw any benefit from this post, you need to have a running version of the DSL we created last time round. If you're new to this series, please go back one week and follow along the steps outlined in last week's article. It shouldn't take you longer than 30 minutes, and I promise we'll wait here for you.

Create a main template

As we're probably going to create more than one kind of class (we'll have Entity beans, DAOs and maybe some interfaces), it is a wise idea to separate all those templates into separate files. The code generator then needs to invoke all those template files in order to generate our application. To make things more maintainable, every code generator should have a main entry point, so let's create a main template file which serves as this main entry point.

First, please delete everything in org.xtext.example.entity.generator/templates. Then, create a new Xpand template in this directory by selecting File -> New -> Other ... -> Xpand Template. This is going to be our main template, so let's call it Main.xpt. An empty editor will open.

Insert the following line:

«IMPORT entity»

In case you wonder how to insert the special quotation marks, use code completion (press CTRL + Space, or CMD + Space on a Mac) to insert them. Upon activating code completion, a dialog will appear, asking you whether to add the Xpand nature to the project. Please confirm this dialog.

The IMPORT statement imports the metamodel of your DSL, thereby making it known to Xpand, which will enable us to use the metamodel in our templates.

Next, add the following lines:

«DEFINE main FOR Model»
  «EXPAND Entity::entity FOREACH this.types.typeSelect(Entity)»
«ENDDEFINE»

This will add a new template called main to your template file. By specifying FOR Model, we specify that this template will later be bound to a variable representing your model. The EXPAND...FOREACH statement will invoke a template called entity in a template file called Entity for all elements of the collection types in your model. Remember, your model contains a number of entities and type definitions. These are stored in the collection types. The typeSelect(Entity) statement makes sure the generator only considers elements which are of type Entity (we do not want to create Java beans for the plain data types).

Create a template for Java beans

Every data-oriented application needs a bunch of classes to hold the data. Usually referred to as entities, these classes are POJOs in our case. So, let's now create a template which helps us to create POJOs from our model.

Please add another Xpand template to your project by selecting File -> New -> Other ... -> Xpand Template. Name the new file Entity.xpt, making sure to save it to the same folder as Main.xpt.

Again, start the file by importing the meta model:

«IMPORT entity»

Next, add the following lines:

«DEFINE entity FOR entity::Entity»
  «FILE this.name + ".java"»
    public class «this.name» {
      «EXPAND attribute FOREACH this.attributes»
    }
  «ENDFILE»
«ENDDEFINE»

This template will create a new Java file for each entity instance it is invoked for. This is achieved by the FILE statement, which takes the name of the output file as it's first parameter.

As you can guess, we also need a template to create the attributes, so please add the following lines:

«DEFINE attribute FOR Attribute»
  private «this.type.name» «this.name»;

  public void set«this.name.toFirstUpper()»(«this.type.name» «this.name») {
    this.«this.name» = «this.name»;
  }

  public «this.type.name» get«this.name.toFirstUpper()»() {
    return this.«this.name»;
  }
«ENDDEFINE»

This template will create a private field, a setter and a getter for each attribute it is invoked for.

Create a template for a DAO

To load entities from a database and save them back, we will need to write some entities, but again, this is something the generator can do for us, so let's write a template:

Create a template DAO.xpt and insert this text:

«IMPORT entity»

«DEFINE dao FOR entity::Entity»
  «FILE this.name + "DAO.java"»
    import java.util.Collection;
    import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
    public class «this.name»DAO
      extends HibernateDaoSupport {
      «EXPAND crud FOR this»
    }
  «ENDFILE»
«ENDDEFINE»

«DEFINE crud FOR Entity»
  public «this.name» load(Long id) {
    return («this.name»)getHibernateTemplate().get(«this.name».class, id);
  }

  @SuppressWarnings("unchecked")
  public Collection<«this.name»> loadAll() {
    return getHibernateTemplate().loadAll(«this.name».class);
  }  

  public «this.name» create(«this.name» entity) {
    return («this.name») getHibernateTemplate().save(entity);
  }

  public void update(«this.name» entity) {
    getHibernateTemplate().update(entity);
  }

  public void remove(«this.name» entity) {
    getHibernateTemplate().delete(entity);
  }
«ENDDEFINE»

Do not forget to invoke this template from the master template file Main.xpt:

«IMPORT entity»

«DEFINE main FOR Model»
	«EXPAND Entity::entity FOREACH this.types.typeSelect(Entity)»
	«EXPAND DAO::dao FOREACH this.types.typeSelect(Entity)»
«ENDDEFINE»

Create a model

In your workspace, open org.xtext.example.entity.generator/src/model/MyModel.entity, making sure it contains the following model:

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

entity Customer {
  String firstName
  String lastName
  String email
  Address shippingAddress
  Order* orders
}

entity Address {
  String line1
  String line2
  String city
  String postcode
  String state
  String country
}

entity Product {
  String description
  Double price
}

entity Book extends Product {
  String ISBN
  String author
}

entity Order {
  Date orderDate
  OrderLine* orderLines
}

entity OrderLine {
  Product item
  Integer amount
}

Setting up the generator

Before we can actually start the generator and transform our model, we need to adjust some aspects of the generator project.

First, please open the generator workflow in /org.xtext.example.entity.generator/src/workflow/EntityGenerator.mwe. We need to change the name of the root template so it matches the name of the root template we chose. We also would like the generator to format the output properly, so we're going to add an output beautifier.

Change the generator component in the workflow file to match the following:

  <component class="org.eclipse.xpand2.Generator">
    <metaModel class="org.eclipse.xtend.typesystem.emf.EmfRegistryMetaModel"/>
    <fileEncoding value="MacRoman"/>
    <expand value="templates::Main::main FOR model"/>
    <genPath value="src-gen"/>
    <beautifier class="org.eclipse.xpand2.output.JavaBeautifier"/>
  </component>

Note: you need to leave the fileEncoding attribute as-is. The above fragment is valid only on a Mac.

As the formatter is based on the Eclipse java formatter (see also this post on the Eclipse code formatter which I wrote some years ago and which still drives 200 reader/day to my blog), we have to add some bundle dependencies to the generator project.

Do to so, please open /org.xtext.example.entity.generator/META-INF/MANIFEST.MF, go to the Dependencies and add the following bundles:

• org.eclipse.jface.text
• org.eclipse.core.runtime
• org.eclipse.jdt.core
• org.eclipse.xtext.log4j
• com.ibm.icu

Running the generator

To run the generator, simply select the workflow file /org.xtext.example.entity.generator/src/workflow/EntityGenerator.mwe and choose Run as... -> MWE Workflow from the context menu. You'll see a bunch of log messages in the console view, and after a few seconds, you'll find a bunch of just generated files in /org.xtext.example.entity.generator/src-gen.

Using the DSL to drive the generator

In the above sample, we wrote the DSL model by hand (well, you probably just copied it from this post), but this certainly is not the normal usage pattern. So, how can you use the DSL editor to create models that are then being read by the generator?

Actually, it is very easy if you follow these steps:

1. Start the DSL in a runtime workbench (refer to the last installment to see how)
2. In the runtime workspace, create a new Eclipse Plug-in Project. Choose any name you like, e.g. org.xtext.example.entity.mymodel. Make sure you deselect Generate an activator... on the second page of the wizard - we don't need one.
3. Add all of the following dependencies to the newly created project's manifest file:
   • org.xtext.example.entity
   • org.eclipse.xpand
   • org.eclipse.xtend
   • org.eclipse.xtext
   • org.eclipse.emf.mwe.core
   • org.eclipse.emf.mwe.utils
   • org.eclipse.xtend.typesystem.emf
   • org.eclipse.jface.text
   • org.eclipse.core.runtime
   • org.eclipse.jdt.core
   • org.eclipse.xtext.log4j
   • com.ibm.icu
   • org.xtext.example.entity.generator
4. Create a new workflow file in /org.xtext.example.entity.mymodel/src/workflow/EntityGenerator.mwe and insert the following text:

   <workflow>
     <cartridge file="workflow/EntityGenerator.mwe" model="classpath:/model/MyModel.entity"/>
   </workflow>
   		

5. Patch the workflow file in the generator: Go back to the original workspace and change the line containing <component class="org.eclipse.xtext.MweReader" uri="... to <component class="org.eclipse.xtext.MweReader" uri="${model}">
6. Go back to the runtime workspace and create a new file MyModel.entity in /org.xtext.example.entity.mymodel/src/model/MyModel.entity.

You can now use the DSL editor to create your model. The generator can be started by running the generator workflow file EntityGenerator.mwe in your newly created model project /org.xtext.example.entity.mymodel in the runtime workspace.

Conclusion

I hope the last section didn't bother you too much. The good news is that we're going to provide a wizard which will help you setting up DSL model projects - see bug 281214.

Due to space limitations, this example is not complete in a sense that you can generate a fully functional CRUD application from it. You should, however be able to see what's possible with textual DSLs and code generation.

If you're interested in seeing the whole generator, drop me a line (peter dot friese [at] itemis dot de) or DM me on Twitter (my Twitter ID is @peterfriese).

Download the code

Download the code from my SVN repository.

Thanks for reading this post. You should follow me on twitter here

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 (itemis) 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.

Download the code

You can check out the code from this SVN repository location.

Thanks for reading this post. You should follow me on twitter here