My startup BeamApp builds a consumer product for mobile users

I was carrying the idea of building a “real” product for quite some time. So, after extensive discussions with friends, colleagues, other entrepreneurs and the directors of itemis I finally decided to leave my efforts in “consulting services” behind and to create my own business. It’s called BeamApp and focusses solely on building a consumer product for the growing market of mobile users.

As HackFwd reports:

With BeamApp, you can pass your current context from one device to another to continue an ongoing task with the gadget that fits best. A hassle-free, wireless setup and a seamless integration for dialing, texting, surfing, directions or music simplifies your mobile life. It works on iPhone, Android and BlackBerry with any laptop, netbook and tablet that runs Windows, Mac OS X or a browser.

Thanks to Lars Hinrichs I got funded by HackFwd for roughly a year. From here, I will concentrate on the minimal viable product first, so please apologize the poor artwork and lack of promotion at the moment. If you want to stay up to date, follow BeamApp on Twitter and subscribe at BeamApp’s teaser page.

You do not believe how excited I am about this step!

The new Xtext website comes with many cool features

When you first open the new website you will notice an extensive realignment compared to the previous version. The site leverages various CSS3 features such as animations (look at the subtle “2.0″ glow), smooth hover effects or a slider-based navigation at the top.

In addition to various news streams that collect blog posts, tweets or commit statistics, there are randomly drawn quotes from happy Xtext users. Talking about mashups and happiness: The documentation now integrates with Disqus (at the bottom of every page) so you can give direct feedback on any topic or provide useful code snippets to others!

From a technical perspective, the “Install Now” button at the top is the most interesting enhancement: It supports the new Eclipse Marketplace Drag&Drop installation feature that comes with Indigo. Still, if you just click on the button, you will be guided to the classic Xtext download page (thanks to some JavaScript). Both alternatives are explained with an HTML5-powered animation (read: NO FLASH) that appears once you hover over the button. Yes, there’s definitely some hype going on…

Unfortunately, I couldn’t contribute much code to the Xtext project over the last two years. Working on the Xtext website once a year is my attempt to say: “Thank you, Xtext team. Your work is great!”

PAGE 3.11 - practical experiences from different areas about collaboration of design and implementation collected on 11 pages

The PAGE article collects examples of several professionals to give an overview of today’s processes in the area of print, web, and mobile. Throughout the interview I had with the editor, several tools, good and unavoidably bad experiences came into my mind. Most of the time, I was talking about what works well (avoid the man-in-the-middle, keep a good relationship and use the right tool for the job) and emphasized a single advice: Do not treat apps as “just a small website” if you want to keep to the budget. Also, if you carefully look on page 31 you might notice the featured NIVEA Waterfall Race I wrote about before from a technical perspective.

mobile business 03.11 - you can read my German article about mobile web and native apps online

The mobile business asked me to write about the controversially discussed topic “mobile web or native apps?”. Even though I can see high potential on current mobile web technology it’s still not on par with the native counterpart when looking at user experience and features such as the camera or app store distribution. Addressing decision makers and non-developers I skipped technical details of cross-platform development but explained the different alternatives (including hybrid apps) in words one could use to make a business decision and to find the right developer instead. Also, you can find a reduced pro/con list for these two approaches. This article is available online, too!

Both magazines can be ordered online and are of course part of our company library. So, if you happen to visit us in Hamburg you are more than welcome to flip through our copy.

Links

• PAGE magazine issue 5.11 (German)
• Online version of my article “Allzweckwaffe oder Spezialist”, mobile business issue 03.11 (German)

My blog's front page with and without cascading style sheets.

Not only do web standards such as Cascading Style Sheets (CSS) build the solid foundation of every browser-based endeavor. On a political level their existence encouraged the community and vendors of different origins to consolidate their work over time, eventually to the advantage of us – the online citizens.

For years, the Acid tests let users discuss how standard compliant their browsers (with respect to CSS) were. Recently, the HTML5 logo initiative came up and tries to make the technology huddle easier to understand for mere mortals. And this is where the Naked CSS day comes in:

The idea behind [Naked CSS Day] is to promote Web Standards. Plain and simple. This includes proper use of html, semantic markup, a good hierarchy structure, and of course, a good ‘ol play on words. It’s time to show off your <body> for what it really is.

Once again, thank you – Håkon Wium Lie, the W3C and the web community! For a single day, I will deactivate CSS to honor your work.

Studying this year’s conference program, I can find a set of related talks covering technologies and approaches I was discussing during my talk:

• Plattformübergreifender Datenzugriff für iPhone und Android
  Peter Friese | Tuesday, 11.45 – 12.45 | Sidney
• Front- und Backend-unabhängige Mobilisierung von Enterprise-Applikationen
  Tobias Philipp | 14.45 – 15.45 | Ballsaal B
• Hybride Apps
  Matthias Proske | Tuesday,  17.30 – 18.30 | Atlanta
• Mobile Web Apps mit JavaScript, CSS und HTML5
  Matthias Lübken | Wednesday, 10.00 – 11.00 | Ballsaal A
• Anwendungsentwicklung für iOS und Android mit Sencha Touch und PhoneGap
  Stefan Kolb | Wednesday, 11.30 – 12.30 | Ballsaal A
• The Next App Generation – Die Zukunft liegt im Mobile Browser
  Jan Webering | Wednesday, 16.00 – 17.00 | Ballsaal A

So, if you are interested in cross-platform mobile development, make sure to visit those. Also, my colleague Peter Friese will be on-site throughout the whole conference and would be happy to answer any of your questions about MDSD for mobile devices.

Have fun at @MobileTechCon and be sure to let me know about the event on twitter!

Links

• Live recording on vimeo
• Slides of that talk on slideshare
• Orignal blog post discussing these slides

You can find the few slides we presented before and after the live-coding on Slideshare

First, we presented a domain-specific language for data-driven mobile applications. Our goal was to build an application similar to the official EclipseCon conference apps during the show. The application listed every speaker with a picture, bio and a list of talks. Also, a schedule for every day could be browsed where details of both speakers and sessions were revealed once you clicked on an item of the list.

As you might know, there are quite a few options to produce cross-platform native (and look-alikes) mobile applications from a single source. As itemis is specializing in model-driven approaches, we picked a domain-specific language to describe the application together with a code generator that produces the appropriate source code of the different platforms.

For the iPhone, we started by adding a “News”-Tab listing recent blog posts written by employees of itemis. The code generator produced Objective-C code as expected and we had the first native application right on the screen.

On Android, we enhanced the application a bit further. Based on the names of the blog authors we built a mash-up and integrated each blog entry with the related speaker’s profile of the existing conference app. The generator produced the needed Java code and we happily deployed it on the “gorgeous” (as Peter said) Android Emulator.

Yet another set of generator templates produced a Python/Django web application we pushed to the cloud as we went on. It was running on the Google App Engine and represented what I am recommending to most of today’s mobile endeavors: “Have at least a minimalistic mobile web site that runs on any phone”. One of the attendees brought a BlackBerry Bold on stage to proof everything worked out fine – thanks for that!

Different result from the same input: Windows Phone 7 displays a Pivot Control instead of a tab bar

Now, the tricky part began. One of our iPhones served as an external camera and “Lazy Peter” used GitHub to push some generated C#-code from his MacBook to an instance of Visual Studio running inside of a VMWare virtual machine (the reason being that accessing code on a networked drive is being considered harmful by Visual Studio). From there, Peter deployed this automatically produced app to a phone running Windows Phone 7.

For the grand finale, we put all of our phones (iPhone, Android, Windows Phone 7) plus two of the attendees’ BlackBerry devices running the mobile web app on a table and put this lineup on the two big screns with our iPhone camera to show how we used one single model to generate native apps for the various platforms while taking advantage of their respective UI paradigms (such as Pivot Controls on WP7).

For Peter and me, it was great fun to see what one can accomplish within half an hour of live-hacking on stage. Unfortunately, we couldn’t talk to everyone who came to the front after the show but we’d love to answer every question you’ve got. At EclipseCon, you can find us at the Xtext booth on the first floor, or at the bar later at night. Also, please feel free to follow us on Twitter (@HBehrens and @peterfriese) or drop us a mail.

We will both attend the Xtext tutorial tomorrow morning

• Pragmatic DSL Design with Xtext, Xbase and Xtend 2
  Thursday, 10:30, 2 hours and 30 minutes | Ballroom A
  Sven Efftinge (itemis AG), Sebastian Zarnekow (itemis AG), Jan Köhnlein (itemis AG)

and start polishing what we presented. Later, we will publish it on GitHub. I will provide a link here, as soon as we are done. Please, stay tuned.

Links

• Our Slides on Slideshare
• Official iPhone conference app
• Official Android conference app
• Minimalistic website on Google App Engine
• Source Code on GitHub (coming soon)

What can we expect from IBM Watson in the future and how is it related to Eclipse? Find out at David Gondek's Keynote at EclipseCon on Tuesday (Eclipse Icon courtesy of Shaun Smith)

Beyond the aforementioned talk by Peter and myself

• Cross-Platform Mobile Development with Eclipse
  Tuesday, 17:00, 40 minutes | Ballroom BC
  Peter Friese (itemis AG ), Heiko Behrens (itemis AG )

there are a few other sessions I am looking forward to attend

• INTERSTELLAR THERMONUCLEAR WAR … with ECF – Multiplayer Game Development for High-Latency Mobile Networks
  Monday, 13:00, 20 minutes | Ballroom D
  Mustafa Isik, Sebastian Schmidt
• Effective Git
  Monday, 15:40, 2 hours | Stevens Creek
  Chris Aniszczyk (Red Hat, Inc.), Stefan Lay (SAP AG), Matthias Sohn (SAP AG), Shawn Pearce (Google Inc.)
• What’s Cooking in Xtext 2.0
  Tuesday, 14:00, 20 minutes | Ballroom A
  Jan Köhnlein (itemis AG), Sebastian Zarnekow (itemis AG)
• Graphiti and GMF Compared: Revisiting the Graph Editor
  Tuesday, 14:30, 40 minutes | Lafayette
  Koen Aers
• Building a Great Community for Your Open Source Project
  Tuesday, 16:30, 20 minutes | Lafayette
  Ian Skerrett (Eclipse Foundation)
• Codegeneration Goodies
  Wednesday, 10:40, 20 minutes | Stevens Creek
  Moritz Eysholdt (itemis AG)
• JavaScript Debugged
  Wednesday, 14:00, 20 minutes | Ballroom BC
  Simon Kaegi (IBM)
• Pragmatic DSL Design with Xtext, Xbase and Xtend 2
  Thursday, 10:30, 2 hours and 30 minutes | Ballroom A
  Sven Efftinge (itemis AG), Sebastian Zarnekow (itemis AG), Jan Köhnlein (itemis AG)

Apart from these, there are many other talks worth attending, but listing those eventually would result in a copy of the official program (the program committee did a great job, again). I am expecting interesting conversations and social activities (like last year’s iPhone Mars Rover) to happen, too.

But, my personal highlight is the keynote on Tuesday about IBM Watson by David Gondek:

• Keynote – What Is Watson?
  Tuesday, 09:00, 1 hour | Ballrooms ABCD
  David Gondek (IBM)

Over the last weeks, I watched more than five hours of video material and read countless interviews and articles about Watson. There’s just so much potential in this technology and the whole industry of computer-supported activities. By any chance, users will use computational time from systems like Watson in the not-so-distant future to verify their personal goals, collect evidence, do research or -in case of a keynote- have some fun. If we had the chance to let Watson calculate the question for a clue at EclipseCon, my take would be:

Conferences $500: Started as a User’s Group Meeting in 2002 this anual “family event” became the most recognizable celebration of a community named after the obscuration of a celestial object.

Anyway, I am looking forward to four engaging days in Santa Clara and I am thinking of everyone who could not make it this year like Ekke, Lars, and especially our friends from Japan.

This package contains a set of four different skins including overlays for a glare effect.

Thanks to the great work of Alexander Gillis, I was able to create these skins with their native screen resolution at a superb image quality. They offer a glow effect when hovering over the hardware buttons, render a subtile drop shadow on both orientations and come with smooth corners on every edge. However, the outstanding feature of this set of skins is the fitting overlay image that can be put on top of the actual emulator screen. It’s based on the Android Emulator’s mostly unknown support for “onions”. That is a feature other mobile simulators, especially the iPhone simulator, do not provide (although tools like simfinger offer a great workaround).

These skins come with a glare effect above the actual screen, highlighted hardware buttons, smooth corners and a subtile drop shadow.

I produced these skins especially to record screencasts and to take high quality screenshots of running Android applications with respect to the actual screen resolution of the devices and their physical proportions. Therefore, these skins come at a relatively large size in pixels that might exceed your average 1600×1200 display. Nevertheless, you can still run them on smaller screens by passing the scale option to the Emulator on startup or by specifying the scale options with “Scale display to real size” on the dialog “launch options”.

# scale emulator to half of its actual size
-scale 0.5

To activate the glare overlay you have to specify an “onion” by passing another command line option to the Android Emulator (sorry, there’s no dialog to do this). Each skin has its own “overlay.png” to seamlessly continue the reflection visible on the body. Be sure to pass the full path to the appropriate graphic along with 100% opacity.

# activate the glare overlay
-onion-alpha 100 -onion <absolutePathToSkin>/overlay.png

Each included hardware.ini contains an example of these arguments. If you are familiar with Android Emulator skins, go ahead and download the archive or fork them on GitHub. The clueless remainder of the Android developers should follow these briefly outlined installation steps.

Installing the Emulator Skins

An Android Emulator skin basically is a folder consisting of files for graphics and configuration. Once installed, skins are named after their folder names. Let’s start and download the ZIP archive containing the skins. After extracting the archive you will find a set of different folders corresponding to (fictitious) device names, e.g. “NEXUS-S” . Each of these folders is what’s called a skin.

Locate the “platforms” folder of your Android SDK. Each platform has its own set of skins you can find at “<AndroidSDK>/platforms/<platform>/skins”. Assuming you are developing against the Google API of Android 2.1, the proper platform would be 7. If unsure, have a look at your AVD manager. Extract the desired skin into the platform’s skins folder, e.g.

~/dev/android-sdk-mac_86/platforms/android-7/skins/NEXUS-S
c:\android-sdk-windows\platforms\android-9\skins\NEXUS-S

Now, restart the AVD manager so it is aware of the new skin and create a new virtual device based on one of your freshly installed skins.

Create a new AVD with one of the freshly installed skins.

You can use this AVD similar to any other virtual device, but as written before, these skins are quite large. If you want to reduce the size of the emulator window, be sure to explicitly pass a scaling factor. Yes, you can do this with a graphical dialog from within the AVD Manager but doing so will thwart your whole development process later on. Instead, I will show you how to configure your Eclipse run configuration since this will be needed for the glare effect anyway.

Change your Eclipse run configuration to scale your emulator window and activate the glare effect.

In Eclipse, go to your run configuration and open the tab “Target”.  Choose “Automatic” for the option “Deployment Target Selection Mode” and select your new virtual device. Also, in the field “Additional Emulator Command Line Options” at the bottom pass these values (where <absolutePathToSkin> had been changed accordingly):

-scale 0.5 -onion-alpha 100 -onion <absolutePathToSkin>/overlay.png

Hit “Run” and watch the console output on startup. The Emulator will tell you if it cannot find the onion file. If everything went right, you should see your Android application within a beautiful Emulator window by now.

Have fun!

Links

• Download Android Emulator skins for Nexus S and Nexus One
• Fork the skin set on GitHub
• More beautiful graphics by Alexander Gillis on DeviantArt

The Feed Sanitizer normalizes your invalid web feed

Here’s a short description of what the service actually does. Please don’t feel offended by these words. They had been taken directly from the project’s website and try to provoke a more personal relationship to its users:

The Feed Sanitizer takes any news or web feed and turns it into straight, normalized RSS 2.0 / ATOM 1.0. This comes in handy if you are confronting with tangled or messed or knocked up feeds that are barely well-formed and want to parse these with a not-so-solid piece of software. The Feed Sanitizer scrubs off the dirt and returns germ-free feeds.

You could simply pass through a given URL to receive a normalized feed of the desired format, download the result once, or just look at the pretty-printed output with the embedded XML viewer.

For those of you interested in the technical details, the service has been written with Python and runs on Google App Engine. It uses several open source libraries such as djangoappengine, feedparser and SyntaxHighlighter.

The Feed Sanitizer is free and ready to serve you. It’s open source, too! Feel free to fork it on GitHub.

Ge.tt is easy to use and offers unmatched quality

Ge.tt comes with a sleek interface and a hassle-free process. There’s no registration required, it creates a convenient download page with previews while your upload is still ongoing, and deletes files automatically if they hadn’t been accessed within two weeks. In comparison to many other services, there’s no averting size limitation (well, individual files may not exceed 2GB) or number of shares you create per month.
Free accounts will give you additional services such as statistics, or “admin rights” on shares to modify their contents after publishing. But even without having a dedicated account, Ge.tt keeps a history of your shares without the need of a password as long as you browse the site with the same machine (based on cookies).

As I am writing this post there had been more than 291.900 shares created (20+ of them by myself) with Ge.tt since its launch in November and services such as TechCrunch or Mashable are as excited as I am.

Wishing the best for the Ge.tt team I am looking forward to seeing how your paid service could be even better.

A few months ago, I read Olivia Mitchell’s free e-book “How to present with Twitter (and other backchannels)” and stumbled across the tool keynotetweet she mentions throughout her advices. Unfortunately, the tool stopped working when Twitter changed its authentication mechanism to OAuth. Instead of modifying the bunch of AppleScript (well… you know) I decided to come up with pyKeynoteTweet.

The tool allows you to send out tweets while you give your presentation with Keynote. It does so by looking for the pattern

[twitter]your tweet[/twitter]

in your presenter’s notes. Each time a new slide with this pattern appears during presentation mode it sends out the payload. You can refer to other people (e.g. @hbehrens) or use #hashtags as you are used to. The script warns you for tweets that exceed the 140 character boundary of Twitter before you start your presentation and avoids repetitive tweets if you go back to a previous slide when questions arise.

Olivia Mitchell lists some benefits of using Twitter during your presentation and I can only encourage you to try it out. Not only does it help you to receive more feedback (some people do not like to speak up), and encourage your audience to spread your word (RT: your point). It’s also a good starting point for virtual discussions and digital relationships.

Download or fork pyKeynoteTweet on GitHub and let me know about your creative ways of using it.

By the way: My next talk complemented with this script will be at beyond tellerrand on Monday, 7 February. Stay tuned and follow me on twitter!

Links

• pyKeynoteTweet on GitHub
• e-book “How to present with Twitter (and other backchannels)” by Olivia Mitchell

Every second attendee has used one of our apps (Photo: Anne Jacko)

We derived quite a few numbers from the download data of the various sources and personally I am quite proud to say that every second attendee has used one or the other version of our app. During the conference about 225 people out of 467 attendees downloaded the native Apps (iOS: 154, Android: 71) and 8 people managed their schedule with the website (201 people tried it but picked only three or less sessions). Compared to the survey the Eclipse foundation carried out as part of the registration process every single iOS user downloaded the iPhone app! Only 73% of the Android users downloaded the app and 17% of the remaining group (including Nokia and Blackberry owners) used the mobile website.

One can interpret these numbers in different ways. “Native apps are far better than mobile web”, I heard several times. “Your mobile website should be improved- who need apps?” reflects another opinion. The Blackberry users might have used Ekke’s prototype (attendees with Blackberry according to survey: 17, actual downloads: 31) instead of the website. Others generally put these numbers into question (134% of the iOS users downloaded the app?). I’d like to overcome this uncertainty with even more data.

EclipseCon 2011

Currently, we are talking with the Eclipse foundation to develop another conference app for the upcoming EclipseCon 2011. To deliver the best experience we would like to collect your wishes and ideas. Please use the quick polls below and/or leave a comment to push us in the right direction.

Thank you! And again: Please leave a comment to give feedback beyond the polls.

Why Cross-Platform?

More than eight major platforms such as iOS, Android, Symbian OS, BlackBerry OS, Windows Phone 7, MeeGo, HP webOS, or bada with different programming languages and paradigms each currently struggle for predominance of the mobile market. Not even looking at the vast amount of different devices, the sheer number of app stores (currently 94) indicates a growing diversity of today’s market.

When producing mobile apps, the key problem arises in the conflict between market penetration on the one hand and cost of development on the other. If you want to address the majority of today’s mobile users you could either develop your app for each of these platforms independently, or try to follow a cross-platform strategy in order to cut the invest. While the former means running several parallel traditional software projects (with all their individual consequences) in parallel, the latter approach tries to reuse parts of the intellectual achievements (often source code) while accepting other drawbacks.

Mobile Web vs. Native Apps

A wide range of software companies and clients choose mobile web applications as a proven way to address any mobile device that features a web browser. At my presentation I used the website of tageschau.de and SPIEGEL ONLINE (both German) to demonstrate the difference between classic and mobile-enabled websites. As a cliff-hanger I demonstrated an ordinary unit converter website on the iPad as well as an optimized web-based game for the iPhone to debilitate the misconception of a missing app store for mobile applications.

In contrast to the aforementioned web-based solutions I presented the gorgeous convert app by taptaptap. It implements the very same use-case “unit conversion” more elegant and efficient even on a smaller display. The Unreal Tech Demo finally proved that native applications offer certain capabilities that are currently out of reach for web-based alternatives.

Even though mobile apps made a big step forward of the last years, they still suffer from technical limitations including visibility on the market due to the absence of an “official” distribution channel. Also, native apps are superior regarding user experience – the foremost reason that made apps such a huge success in the first place.

Both aspects might change over the next years.

Mobile Web Apps

Looking at the current state of the art of software development, I gave an overview of several available libraries including iWebKit, iUI and jQTouch. I think of these as a reasonable set of CSS and JS to let you express yourself with simple HTML. Sencha Touch on the other hand follows a programmatic approach where the developer leverages a rich API to express herself without HTML or CSS but with pure JavaScript code. The JQuery mobile framework is waiting in the wings to combine the best of both worlds. It is announced for 2010 Q4.

Using any of these libraries simplifies the development of a native-look-a-like web app but comes at a cost. One cannot reuse an existing set of HTML but has to produce properly redesigned documents suited for the given framework. Also, these frameworks are far-off from the idea of cross-platform. Only a limited set of mobile browsers are currently supported. If you need a fail-safe web-based solution you have to stick with an even more cut down feature set or implement platform-specific mobile websites.

Hybrid Apps

One of the major drawbacks of mobile web applications is the lack of  the lack of direct access to individual features of the udnerlying hardware platform. Even though recent versions of mobile browsers propagate information such as screen orientation or geolocation they are still limited. There is neither a common way to read the accelerometer nor can one access the camera to upload a video.

This is where frameworks such as PhoneGap come into play. Basically, it’s a thin native application that is only little more than an embedded web browser. The user receives an ordinary native app that displays web content under the hood. With a simple technique called HTTP request interception (sorry, cannot find a suitable link) these frameworks bridge the gap between device and a web app. The developer can use a JavaScript-API to read additional data from the device and trigger actions such as vibration in a standardized way across the different native platforms.

Hybrid apps combine advantages of the native world such as distribution via the app store with common web technology as outlined above. But since the rendering and interaction relies on an embedded web browser they appear to me as the poor-mans native app. The user downloads and pays for a native app and therefore should not be disappointed. The developer is required to spend a considerable amount of time to make the included web app look and feel as a native counter part in order to match these expectations.

Interpreted Apps

Interpreted apps use platform-specific native UI elements to interact with the user whereas the application logic is captured in a platform-independent way. This can be a set of commands in XML or another description language (ipfaces, JMango, ramp). Other technologies such as MonoTouch (.NET) or Rhodes (Ruby) implement full execution environments of existing programming languages. The most prominent competitor no doubt is Appcelerator Titanium. During my talk I illustrated how you can use a JavaScript-API to produce quasi-native apps for iOS and Android.

This approach offers a number of benefits but has an inherent drawback at the same time. Developers are tied to the feature set of the chosen framework whenever the demand exceeds the foreseen possibilities of the given technology or cannot catch up with new features of a platform (e.g. iPhone’s Retina Display). Even though some of these technologies are open-source and offer extension mechanisms, the developer has to stick with the paradigms of the chosen framework. Therefore, she cannot use a project-specific short-cut to deliver the unforeseen remaining 20% of the app without following the restrictions of the framework.

Generated Apps

The common idea of this approach is to produce truly native apps for each targeted platform with its respective programming language from a single code-base. During my talk I presented xmlvm and APPlause as two examples of code generators.

The advantages of this approach are manifold and do not end with the extensibility of the produced apps. If needed the generated output can (be adjusted to) interact with every single aspect of the native platform. Even though the results of xmlvm are barely readable, other solutions such as APPlause based on a domain-specific language not only simplify the development process but produce code that conforms to the sample-code in any aspect (let me know if you want to read more about this technology on this blog).

These advantages come at a price of a relatively high upfront investment, though. None of the publicly available technologies is production-ready right now. Nevertheless, if you plan to produce a set of related apps or try to mobilize an enterprise application you should definitely have a look at this approach!

Where To Go?

Unfortunately, there is not one technology to bind them all. The right choice depends on the specific needs of your project and often turns out to be a combination of the aforementioned approaches. At the end of my talk at MTC 2010, I had a very lively Q&A session with the audience regarding this question. S&S allowed me to upload the video recoding of this talk on my blog.

As always: If you need further help with your current project, just let me know.

Also, if you happen to be at this year’s iPhoneDevCon in Cologne (01-02 December) you should attend my session about cross-platform mobile development. I will give a similar, refined presentation with a lot of live demos and more information on the audio track. You welcome to ask more questions over there – but this should not bar you from dropping a comment below.

Update

Meanwhile, S&S media gratefully allowed me to publish a (German) live recording of this talk.

Beginning iPhone Development

This book truly falls into category (A) and explains step by step how to start developing for the iPhone. Dave Mark and Jeff LaMarche not only discuss the concepts of the iPhone SDK. They describe essential little details of the tools you will face during your work such as the key strokes you have to know when using the Interface Builder. Some examples span across several chapters but the authors encourage you to branch out and try things on your own.
It’s still for the iOS 3.0 and doesn’t cover multi tasking nor the retina display or universal apps for iPhone and iPad. But once you have mastered this book, looking up those features on the Dev Center should be easy.

Link to Amazon, Book’s Website

Cocoa Design Patterns

This book definitely is not for beginners, it belongs to category (B). Readers should have worked with Objective-C and other programming languages before to value this great book by Erik Buck and Donald Yacktman. Newcomers to the iPhone development can use this book to gain a deeper understanding of the APIs they will face. Some of the patterns of this book are rather common in other programming languages, others are more or less unique to Objective-C. Over time, you will adapt these patterns to improve the design of your own programs, too.

Link to Amazon, Book’s Website

Tapworthy

This book is a must-read for mobile app developers and you should definitely read it before you seriously think about the development of an iPhone app. Josh Clark shares his deep understanding of the mobile user. To make it clear: This is not a coding book! You will learn a lot about designing interfaces (C), guiding your users through your app and keep them using your app by fleshing out its core features. The colorfully illustrated book rounds out with interesting experience reports by the developers of the Facebook app, Twitterrific, Gowalla, Things, and the like.

Link to Amazon

Yes, there are a lot more exciting books covering iPhone development but these are my personal highlights of the aforementioned categories. Feel free to ask for more recommendations via twitter or in the comments. What are your own favorites?

The game screen has been built with a full motion video behind the HUD and the game layer.

The game screen as seen by the player internally consists of different layers. The top-most layer contains 2D graphics and displays information such as speed or remaining time. Behind this layer (or plate) the dynamic 3D game scene is being rendered. This layer contains the actual game elements the player controls. It has been built with OpenGL and displays the player’s character inside a rolling ball.

Now, in addition to this quite common setup we implemented a third layer in the back that plays a full motion video of a pre-rendered game scene. Even though this technique had been used for games such as Rebel Assault on the PC between the late 80′s and the early 90′s I am not aware of any iPhone game that integrates the game layer as tight as we did with matting and alpha compositing.

Game elements (a) with animated matting (b) appear inside (c) or even "behind" a background movie as illustrated on (d).

In no case we wanted to deliver a separate, affixed game layer above the movie. Instead, we tried to create the impression of embedded game elements (a) as an integrated part of the pre-rendered movie. With the help of an animated alpha mask (holdout matte) that corresponds to the wave movements of the river (b) we were able to let the water appear above the ball (c). And by using a matte with a true alpha channel we were even able to let submerged parts of the scene shine through the water surface as you can see on (d).

NIVEA FOR MEN WaterfallRace is available on the App Store for free and I will write another post including a screencast once the scheduled update for known bugs is out.

We were able to make this compositing feature work on the 1st generation iPod Touch and iPhone with the SDK 3.0. Please let me know if you are interested in the technical details on how to configure the EAGLView and MPMoviePlayerController or how to sync with the movie on the targeted iPhone OS 3.1. Also, please comment on this post if there’s another development aspect of this project you want to learn more about.

Update: Read the follow-up post about the NIVEA FOR MEN WaterfallRace.

Different functions to separate actual and displayed speed values

During our first phase of interaction tests we constantly got the feedback that the speedo was not accurate, though. Players had the impression to be way faster than the value displayed by the gauge. Others complained about how hard it was to gain speed in the lower region.

We decided to separate the actual speed used for game logic from the displayed value as shown by the speedometer. The paper “Rethinking the Progress Bar” I stumbled across a while ago when I was improving the user experience of a desktop application came in handy to do so. Chris Harrison et. al. discuss how different update rates of ordinary progress bars change the user’s perception of progress duration. They come up with some simple, yet useful functions to map a real progress value x to the displayed value f(x).

Selection of functions as described in Rethinking the Progress Bar

Whereas the results in the paper highlight functions that produce an accelerating progress bar in the end we needed to achieve the opposite for our game.

My speed is quite good by now but I am not at top speed, yet. I will try harder.

On slow speed ranges our speedometer simulated a higher speed and greater variation on speed changes. Beginners got immediate feedback and felt success that way. High speed values on the other hand were visually more difficult to achieve. That behavior seemed to motivate advanced players.

We first used the Inverse Fast Power function but eventually settled on Late Pause. No player ever mentioned a mismatch between the actual and the displayed value after our adjustments and nobody seemed to recognize the fake.

Links

• NIVEA FOR MEN WaterfallRace on the App Store
• “Rethinking the Progress Bar” by Chris Harrison, Brian Amento, Stacey Kuznetsov and Robert Bell
• itemis mobile application development

A week ago I stumbled across a small and free tool by Nicholas Zambetti called LiveView you can find on the App Store. Its concept is easy: On your Mac you run the LiveView ScreenCaster. That counter part renders an iPhone/iPad frame in its actual (huge!) dimensions on your monitor. Anything that shines through the screen of that imaginary device is being sent over the Wi-Fi. On the iPhone/iPad you can now run the LiveView app. It automatically finds every Mac currently running a ScreenCaster via Bonjour, asks you for the one to display and… Well, that’s it. You can now see your screen pixel perfect without exporting and importing images anymore.

Get a live copy of your screen on the iPad with the LiveView app.

As it turns out, this is just the way you can immediately test out anything you mock on your big screen. The ScreenCaster frame gives you the right idea about the actual dimensions of the device including its borders. You can adjust its position pixel by pixel with the cursor keys and finally press CMD+H to hide it. This is far more convenient than any VNC-based approach I tried before.

From there, work with Photoshop, Pixelmator, OmniGraffle or any other tool as usual. You can hide layers, resize elements, and change your font size while watching everything live on your device.

Impress your client and hand over the iPhone to your stunning audience while swapping layers. Or, use the tool as I did it with my current project at itemis. I looked at a flash website through the iPhone! That way, I was able to gain a first impression of what can be improved with a true iPhone app.

Unfortunately, the ScreenCaster cannot be rotated to send the data in landscape mode. Another flaw is the lack of a Windows version of the ScreenCaster. Nicholas, if you read this: I meant it the way I mailed it. Let me know if I can help you with the Windows port!

Links

• LiveView project website
• LiveView on the App Store
• blog post about LiveView by Gentry Underwood

This blog with and without Cascading Style Sheets on the CSSND.

In my opinion web standards such as Cascading Style Sheets (CSS) tremendously evolved over the last years. Where I used images and tables years ago in order to achieve a proper site layout I can simply use CSS nowadays. In my current project I go even forward and implement transitions, rotations and semi-perspective alignment in a consistent, declarative way.

For a single day, I will deactivate CSS to honor these achievements. Thank you – Håkon Wium Lie, the W3C and the early adopting web community!

The iPad after 15 minutes of usage

Weight and Typing

When I held this device in my hands this morning my first reaction was “oh, that’s heavy”. And in fact, after holding it a few minutes between my thumb and forefinger while swiping and touching through the apps this impression got stronger. Its weight becomes even more annoying while typing when you hold the device with one hand and type letter by letter with the other one.

“Not a problem” you might say, “one can place it on the table to type”. Well, yes and no. I was suprised how stable it was on the tabletop despite its curved flip side. The keys are way larger than those on the iPhone and typing with two hands would be a pleasure if there wasn’t the space bar. Each time I hit the spacer with my thumb the device slightly revolved around its own axis. Only cloth could prevent this.

“Why not using two thumbs for typing”, I thought by myself. This is what I do on the iPhone the whole time and it might work well on the iPad even though it’s larger. I was looking at the virtual keyboard to hit the proper keys with my thumbs and kept quite happy for a few letters. To conquer those larger distances with your fingers is one thing. To focus text and keyboard with my single pair of eyes simultanously simply doesn’t work. The keyboard at the bottom and text at the very top of the screen are so far away from each other on that huge display, this technique doesn’t work anymore. The seesaw between text and keyboard made me feel like I haven’t typed before at all.

In the end, only few postures on the sofa where you place the iPad on your lap worked fine for me.

Glossy Display

At first glance, this might only be an esthetic issue. Having finger prints all over the display is not really the end of the world. It’s just in the eye of the beholder. Right, but having reflections of your ceiling light, sunblinds or windows in general is more than annoying. When one finally found a way to type successfully on the iPad, there are not many options to prevent those reflections anymore. There’s no turnable display lid like the one on your laptop and you cannot easily change the angle between your tables and your windows – once you figured out how to type with two hands.

No Multi-User Support

I think of the iPad as the obvious extension of your living room. Your guests can look-up the soccer results, browse on youtube, pass it around to complete the pizza ordering or even check their facebook status. And the latter is exactly the problem with the iPad. As anything else in your living room the iPad is open to anyone. But what about your mails? What about your browser history and your stored logins? And what about your beloved calender, twitter, facebook or baking apps that grant access at a single finger tip?

Do you really have to lock the iPad? Is it just a toy and must not be used for serious data?

Conclusion

I am still fascinated by the iPad. It’s an amazing (some argue “magical”) piece of technology. I will get used to its weight and will learn how to type and look at the glossy display. But the lack of a “guest profile” or an equivalent way to hide away sensible data is something apple has to work on. Under these circumstances there’s only one option for me to use the iPad in future – I will need two of them.

100% Generated iPhone app of my EclipseCon talk

During my talk on Monday (slides on slideshare), I argued how you can leverage the ideas of MDSD to be more efficient when building iPhone apps with the help of domain-specific languages. To prove this, I built a running iPhone application in front of the audience in just 12 minutes. That application was able to browse the corporate blog of itemis as well as an index of itemis speakers and talks available at EclipseCon. From any screen you could jump to related bits of information. Everything was being loaded on demand and behaved like every other native application on the iPhone – since it is a native app. And the coolest thing: All this without leaving Eclipse!

As you can read in the interview I gave to The Bitsource I understand this particular demo app as an example. It represents an important part of many apps you can find in the stores today and the provided results are substitutional for the whole group of data-centric mobile applications itemis is going to deliver with the powerful help of MDSD.

Me holding the iPhone Mars Rover app. Click the image to watch a video of the iPhone Mars Rover app.

A rather unusual event we stumbled upon was the EclipseCon Mars Rover Challenge held in cooperation with the NASA JPL. It’s idea was to create the very best robotic control system to drive a robot across a prototypical Mars landscape. And guess what? Peter and I set out to deliver an iPhone application to do so.

To make a long and amusing story short, we came up with a vibrating and blinking iPhone app that allows you to steer the robot by tilting the device. Popular Science, Mashable, Slashdot and many other news sites caught up quickly – so we decided to publish a dedicated website (iPhoneMarsRover.com) discussing the details and providing more images on that particular application. At this point I want to thank Carsten and Michael for their invaluable help building that site. It’s a pleasure to work with such talented people.

And regarding the Mars Rover app: In future, we will most probably give droids the chance to hold that app in their hands – stay tuned!

Yes, itemis truly enters the market of mobile applications. And this goes way beyond ordinary iPhone, Android or Symbian apps. We are currently working on something that will knock your socks off! But that’s still a #secretproject…

Update 04/15/10: Dzone interviewed Peter and me about the aforementioned talk as well as the Mars Rover app. Read more details over there.

Links

• Slides of my MDSD on iPhone talk
• Video of the iPhone Mars Rover app
• iPhoneMarsRover.com
• Interview at BitSource about MDSD on iPhone
• Interview at DZone about MDSD on iPhone and Mars Rover

In the end we came up with: Some statistics of the project activity (1), a news aggregator (2), and a condensed (53 secs) introductory screencast (3).

The updated Xtext website displays commit statistics (1), recent blog posts plus other web content (2) and a brand-new introductory screencast (3)

Our project website attracted some attention since it has been launched this June. The AMP project reuses its layout and Denis from the Eclipse webmaster team embraces the results, too. From there, the bugzilla 235828 discusses whether the Xtext website should serve as the standard template for new Eclipse projects.

Currently, you can see such an “empty Xtext website” at eclipse.org/default - how cool is that!

The Bells and Whistles

Even if Denis, Matt & Karl will provide a standard template based on the Xtext website you might want to adapt some of our additional features, too. To support you in doing so, I will summarize the underlying technology of the recently introduced features.

To produce the commit stats (1) the page leverages the commit statistics of Xtext and renders the polished data with the Google Chart API on order to match our visual expectations.

The news section has been built with Yahoo Pipes to scan, filter and aggregate different web resources asynchronously. You can even subscribe to the news feed directly to always stay up to date.

For both the commit stats as well as the news section Denis allowed me to install a cronjob that fetches and stores the results independently from the http requests.

The screencast has been recorded and edited with ScreenFlow. Also, thanks to Sven for the audio equipment!

Let me know if you want me to provide more details.

Nearly 200 attendees, 29 talks on 2 days and 3 winners of the best German iPhone App contest at the iPhone Developer Conference in Cologne

I had the chance to introduce the iPhonical project that applies model-driven techniques to produce parts of iPhone applications automatically. The presentation first describes a way to separate generated code from manually written source with the Objective-C concept of categories. From there, I demonstrated that even with powerful frameworks such as ObjectiveResource (an adapter to connect iPhone apps with Rails applications) one can benefit from code generation. With the help of the iPhonical DSL (implemented with Xtext) keeping data-centric classes in sync with the web application was way easier than coding them by hand.

The iPhoneDevCon was a very informative event. Many passionated developers or leads, growing studios and enthusiastic marketing representatives shared their ideas and during the breaks you could easily discuss different viewpoints of today’s opportunities and approaches.

Apart from the 3 winners of the “best German iPhone app” (according to iPhone & Co) a brand-new iPhone and Mac magazine, mac-developer, has been announced. As the name suggests it concentrates on developers and its first issue is quite promissing.

Links

• iPhone Developer Conference website
• Slides “iPhonical and model-driven software development for the iPhone” on SlideShare
• iPhonical project website
• mac-developer magazine (German)

My talk about model-driven iPhone development in general and the open source tool iPhonical in particular ranks among many other promising talks for developers.

Visit the German iPhoneDevCon in Cologne on December 01-02, 2009

If you are planning to attend please contact me in advance. Being a speaker I can give away a limited amount of promotion codes. This might safe you some expenses and allows you to buy me a drink in return

Frank Zimmermann explained how Eclipse Modeling and Xtext in particular can be used to produce SAP applications. He even gave a live-presentation of the tools his students developed during a research project.

Simon Zambrovski took some photos at the EWiTa

Since the slides I used at the EWiTa were an excerpt from a former talk at the Code Generation 2009 in Cambridge I will only list the related talks I mentioned in the end:

• Xtext Workshop
  Eclipse Summit Europe – 27 October 2009 – Ludwigsburg
• Mastering differentiated MDSD Requirements at Deutsche Börse AG
  W-JAX 09 - 10 November 2009 – Munich
  
• Experience Report by Deutsche Börse AG
  Eclipse DemoCamp Frankfurt – 26 November 2009 – Frankfurt
• Combining Graphics and Text in Model Editors
  Eclipse DemoCamp Hamburg – 04 December 2009 – Hamburg

Links

Meet us at the Eclipse Modeling Days in New York and Toronto

Personally, I am looking forward to the talks

• “Modeling on an Enterprise Scale” (read: “Learn more about CDO”)
  by Eike Stepper and
• “Agent-Based Computer Simulation for Operational Risk Analysis”
  by Ed MacKerrow

to learn more about two exciting topics I am curious about. Of course, itemis will be there as well. Make sure you don’t miss

• “Converging Textual and Graphical Editors”
  by Moritz Eysholdt and
• “Building DSLs with Xtext”
  presented by myself.

Head over to the wiki page to browse the abstracts and register for one of these free events or read some other announcements.

Looking forward to seeing you over there!

Elmshorner Wirtschaftsinformatiktag at Nordakademie near Hamburg

Other talks such as

• “Collaborative Modeling of Business Processes” (Mathias Weske),
• “Test-Driven and Model-Driven combined with openArchitectureWare” (Arne Michael Törsel) or
• “Being Skeptic about MDSD” (Hartmut Herde)

show great promise for interesting discussions. Please note that the aforementioned talks as well as every other talk will be held in German (I freely translated the titles for you).

There’s no conference fee and the organizers will be happy to welcome you at the Nordakademie if you register before October 23rd. So, if you happen to be around Hamburg that Friday don’t miss the 1st EWiTa!

Under the hood, the animated ducky as well as the illusion of water is based on a hand-crafted physics engine. The water is implemented as a particle-based fluid simulation. Matthias Müller published a paper with the same title and great slides for SIGGRAPH 2007 as a starting point if you are interested in this topic. The ducky itself interacts as rigid body with these particles where buoyancy had been implemented explicitly. Play with Erik Neumann’s demo to have fun with rigid body physics. These concepts had been adjusted and combined with the accelerometer and touch sensors built into the iPhone to let the user interact with the simulation.

Different techniques had been applied to realize the illusion of a splashing ducky

Having just dots and circles as one could look at the physics engine was obviously not the ultimate goal. From the raw data of the simulation the water surface area had to be derived, the ducky had to be put in shape and some smooth animations and sounds were needed to round out the illusion of an interactive bathtub.

Without going into every detail I want to emphasize that the iPhone is not a MacBook Pro. Where you traditionally use marching cubes/squares to convert distinct particles into a cohesive area the processing power of mobile devices requires you to squeeze out every cycle by thinking outside the box and taking advantage of hardware acceleration. In this case, OpenGL ES offers a variety of techniques including framebuffers, blending functions and alpha tests to perform the needed steps by the GPU.

metaball technique from particles using blending and alpha functions

Some other findings during the project include the unreliability of sensor data as well as users’ unpredictable behavior. Be aware that humans and machines act differently under certain circumstances. For applications where the interaction between those both is crucial you should do usability tests early, often and extensively before delivery, again.

The iPhone is different from other mobile devices or the emulator. Generally, floating point arithmetic will be evaluated more efficient than fixed-point. Some GPU operations are executed faster on the device than on the emulator, others are of poor performance though. Therefore, you should profile on the device to test different approaches of your design regularly. And: You must not forget to do so with sound enabled since sound processing might take more than 30% of your overall processing power.

So, go ahead and grab your version of the Burlington Duck on the app store:

If you are interested in details (e.g. “unpredictable human factor”, production of the screencast, etc.), please let me know and use the comment function of this post.

Output of the profiler from the Xpand Sample-Project

If you stay with the text-based GProf output format (another option to dump the collected data) you can also use tools like Gprof2Dot to visualize hot spots with colors and callees as painted connections.

Same workflow visualized with Gprof2Dot without reduction of nodes with no impact

The updated documentation explains how you can integrate the profiler into your workflow. Also, the Xpand Sample-Project Wizard creates a second workflow “generatorWithProfiler.mwe” where I have generated the above results from.

In a real-world project we were able to reduce the execution time of a workflow that originally took nearly half an hour down to less than 3 minutes using an earlier version of this profiler. It can also help you detecting unwanted indirections and recursions.

openArchitectureWare moved to Eclipse

The homepage of the working group at Eclipse offers links to ready-to-use distributions and we are working on update sites, too.

I want to thank Peter and Karsten for their help with this. Hopefully, this public notice will encourage even more users to migrate to the more stable and feature-rich version at Eclipse. Again, if you need professional support around oAW itemis will be glad to assist you.

MDSD process shortens development cycles where the customer expects specific applications to calculate different classes of estimation bids

My work as the “technical facilitator” was mainly enjoying the progress and providing alternatives during the sprint review and planning meetings (yes, the group decided to go with Scrum). Without excessive help the students were able to develop a DSL that is able to

• make simple and complex existing data types of the SAP system available to the editor,
• express business formulas based on variables of these types,
• provide a comfortable editor that checks many constraints and guides the expert, and
• describe layout of the UI based on these values.

From this input some Xpand templates generate

• a testbed for these formulas that allows domain experts to capture their expectations within a spread sheet application,
• database table descriptions to store estimates for reference,
• a dynpro frontend including search masks to fill in the needed dimensions and displaying results in real-time, and
• the needed ABAP code to perform the calculations as well as glue code for the SAP system.

Prof. Frank Zimmermann published a short description of this project in the in-house magazine Capusforum of the Nordakademie (German). There will be more material on these results soon: The students are preparing a publication addressing MDSD for Enterprise systems in a larger German magazine. The cimt AG and itemis will use this project to demonstrate the possibilities as well.

For me, this research project is just a proof of concept. I am sure the vast majority of SAP projects can benefit from MDSD principles. Thanks again to Prof. Zimmermann from the Nordakademie, Michael Neuenstadt, Michael Flemming as well as Dr. Kuhlmann from cimt AG and last not least the students. It was a pleasure to work with you!

If you have detailed questions -technical or commercial- don’t hesitate to contact me or the responsible sales representative, Asaf Ikram.

Can you explain this Java error with an ordinary text editor?

For some unexplained reasons one of the spaces (0×20) had been replaced with another character (0xCA) which looks perfectly in any text editor but forces Eclipse to stop with an error. This might be connected with a common mistake I am doing regularly when switching between different types of computers is hitting <ALT>+<SPACE> on my Mac. This produces an “erroneous white space”, too!

Hex Fiend is a sophisticated hex editor for Mac with many handy features.

Meanwhile, I am using Hex Fiend to quickly analyze Java code with such errors but also to look into arbitrary binary data. It allows you to paste snippets from your clipboard directly into the editor and does not force you to search and open a file before. Although it works perfectly with huge files of several Gigabytes (or even Petabytes if you trust their own words) working with the clipboard is really handy. Beyond this it allows you to convert byte ranges to different integer formats and the find/replace actions concentrate on binary data as well.

Give it a try when you have to analyze binary data or your next strange text file the next time.

OBJ2OPENGL does the latter and acts as a converter from model files to C/C++ headers that describe vertices of the faces, normals and texture coordinates as simple arrays of floats.

Texturized and lighted 3D model with 8,056 faces on the iPhone

OBJ2OPENGL is a Perl script that reads a Wavefront OBJ file describing a 3D object and writes a C/C++ include file describing the object in a form suitable for use with OpenGL ES. It is compatible with Objective C and the libraries of the iPhone SDK.

The original idea and code base of this script comes from Margaret Geroch who kindly allowed me to enhance and republish this version. It now supports texture mapping and stored normals (instead of recalculating them). I have changed the structure of the generated arrays to work with glDrawArrays instead of glDrawElements. This is particularly needed for normals and textures where a vertex holds different information for some shapes. Also, this version includes several command line options to better control its behavior (such as scaling and moving the origin or setting the object’s and output file’s name).

If you can go with the defaults the conversion is as simple as

./obj2opengl.pl banana.obj

To include the converted object all you have to do is

// include generated arrays
#import "banana.h"

// set input data to arrays
glVertexPointer(3, GL_FLOAT, 0, bananaVerts);
glNormalPointer(GL_FLOAT, 0, bananaNormals);
glTexCoordPointer(2, GL_FLOAT, 0, bananaTexCoords);

// draw data
glDrawArrays(GL_TRIANGLES, 0, bananaNumVerts);

Examples

These are two models and generated sample output that is included in the provided archive:

Downloads

• OBJ2OPENGL.ZIP (script and examples)
• OBJ2OPENGL.PL

iX Magazin issue 08/2009 prints my article about Xtext

But this is not the only publication that discusses Xtext: Next week the German Eclipse Magazin (issue 5.2009) will start a series by Jan Köhnlein and Sebastian Zarnekow that explains the technology in detail. And Sven Efftinge sums up the recent events around the Eclipse Modeling Project (including Xtext) in the very same issue (online version of this article already available).

Lars Corneliussen and Markus Völter started a series about DSLs in the in dotnetpro (so far, issue 05/2009 and 07/2009). Even though the focus is on .net platform the former version of Xtext (oAW 4.3) plays a significant role.

Unfortunately, all these publications are in German. If you are interested in writing an English article and need someone to review your work or if you have strong connections to English publishers who might be interested in an article written by us, please contact us via xtext at itemis dot com or comment this blog post.

That said, I want to thank the reviewers of my iX article for their valuable feedback!

Links

• Online version of the iX Article
• Links mentioned in the iX Article

If you are looking for a challenge and wanted to play around with Xtext since you heard about it this one is definitely for you. Pimp Xtext the way you want, combine it with colors, graphical aspects or any other technology, work with huge models, come up with a new programming language – your mind is the limit.

Be creative, use unusual techniques, explore your skills, do whatever it takes – we want you to get really excited about it so we will be excited as well.

You will have two months to submit an inspiring solution based on Xtext. And, with a bit of luck, you will not only win an Xtext T-shirt but program your next Java project for an Android mobile phone or meet other Eclipse enthusiasts at the Summit in Ludwigsburg.

Feel free to comment if you have any questions. Good luck!

The webinar will start at 5:00 pm GMT (convert to local time) and will take approximately one hour. We will offer a chat to answer your questions either live or in the end of the show. And since the program is not yet completely settled, it’s your chance to declare anything as a must-see. Just leave your comments here.

Update

The webinar was a great success! With the help of Sebastian and Moritz we were able to inform and entertain 130 Attendees. You can watch the replay at any time and follow some useful links either via its website or directly here:

• Slides (via SlideShare)
• Chess Example (not there, yet)
• Domain Model and Index (via Svens Blog)
• Xtext and GMF (via Jans Blog)

Also, here you will find the final poll results. Thank you for you help, Lynn!

Do you have any experience with modeling? (99 Answers)

What do you think about Xtext? (59 Answers)

Dropbox offers a shared directory directly inside your file system you can then access from different computers simultaneously. It does so by synchronizing with a secure web storage in the background. It integrates tightly into your desktop and works on both Windows and Mac OS (and Linux but I cannot tell you about this). It notifies you whenever a shared file has been modified on another computer and a little icon overlay indicates whether a file is currently being synchronized. Technically, you could compare this to a classic version control system and indeed it comes with a history, too. But its seamless and hassle-free integration allows you to forget about all these details and to work with your image editor or word processor as you are used to, hit save and tell your buddy on the phone to open the file. It’s that easy.

I am using Dropbox for my personal life, too. You can control whether a folder is shared among others or is for private use only (default). I share my dropbox folder accross different Macs and PCs I am working on. When working on a laptop and a desktop at the very same desk sharing files between them is a common task for me. Before, the fastest way to transfer a file between these computers was copying it to a USB Stick, ejecting (and waiting for delayed write) it and mounting it at the other computer again. Funnily enough, sending an email with an attachment is sometimes even simpler than this procedure.

But with Dropbox I save the file into my Dropbox folder or even use this folder as primary editing location for my work. After hopping to the other computer this file in the latest version is already there without leaving any application on the first computer or performing additional tasks.

Dropbox is yet another tool that simplifies your daily life.

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.

Links

• Slides at SlideShare
• Video Podcast at Skills Matter
• Review at InfoQ

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);
	}

}

The first conference day on Tuesday…

…started with a smooth introduction on modeling, DSLs and all the other terms specific to our focal point. It’s always interesting to see how other experts try to explain what we are doing and Juha-Pekka Tolvanen (MetaCase) did a great job even though he nearly ignored alternatives to graphical models.

Second, Sven and Sebastian talked about challenges in textual DSL design and concentrated on topics such as reusing languages and using models beyond the description of structures. If you follow their blogs you will certainly find out what they are interested in. This was the second time I noticed that the audience here at #CG2009 acts a bit more open-minded towards UML models and my coworkers sometimes had to play hardball with questioners.

Karsten and me skipped the next time slot to prepare ourselves for our own talk “Mastering Differentiated MDSD Requirements at Deutsche Boerse AG” we gave at the end of the day. We packed a lot material into 75 minutes but still managed to come up with a short demo that shows how Xtext can interact with graphical models. You can download the slides at slideshare but the demo is not yet ready, sorry (the attendees asked for this, please drop me a mail or comment on this post so I can inform you later on).

Punting in Cambridge (Foto by Karsten Thoms)

After a stressful day, the organized punting trip along the Cam made this day perfect to me.

Wednesday…

…was a completely different story to me. Instead of listening to or presenting well-known ideas I had the opportunity to get some deep insights of concepts I only read about before. After an amusing staged fight between Markus Völter (textual modeling) and Steven Kelly (graphical modeling) my day started with the well-prepared hands-on session about MetaEdit+ Juha-Pekka Tolvanen, Risto Pohjonen and Steven Kelly gave. From what I have seen I would say that this software is the most sophisticated graphical modeling tool at the market today.

The session I have joined afterwards was not that impressive but I compensated for this with today’s highlight: Language Definition, Extension and Composition with MPS. Markus Völter and Konstantin Solomatov complemented one another and impressed the audience deeply with the upcoming version of MPS. This was the first time I have seen a live presentation on this little pearl of modeling.

Some lightning sessions about Fit4oaw, MBase, UMLCanvas and GWT made the end of the technical part. A nice dinner with french impressions made the night a big success again.

I want to thank Mark Dalgarno and Andy Moorly for organizing this event. Questions about the room plan, the need for a different stage setup, giving up their seat at the dinner or ad hoc money exchange for thirsty attendees – no problems for them. Your upfront organization as well as your courteous appearance is simply overwhelming!

Update: This post has been published at The Model Driven Software Network, too.

Links

• Slides of the session at slideshare
• Pictures of the conference at flickr
• Twitter tweeds about the conference

iWannaSleep puts your Mac to bed

Marco Binder has written this little helper that puts your Mac to bed. It acts as a timer, fades out the sound and performs an action. This could be “shut down”, “stop iTunes” or “run apple script”. I usually stay with “put to sleep” (so my Mac has no hangover the next morning). The tool remembers the options I have chosen the last time and has never dozed off itself before doing its job.

People are just starting to explore the possibilities and sometimes it is difficult for them to find the right word to name a concept or share an idea. We do our best to support those seekers and are glad to do away with a common uncertainness: The right spelling is “Xtext” and from today its logo does reflect this.

The new Xtext logo starts with a capital X

Beside every other wrong spelling “xtext” was the most prominent. It took us a while to find out why this was the case. Eventually, we realized that the omnipresent logo started with a lower-case “x” (convince yourself). So it was our own fault!

With the help of Carsten Oltmann we are proud to present the new version of the Xtext logo. Feel free to place it into your presentations, on your blogs or as a sticker at your laptop.

Downloads

I will provide the logo in four different flavours and in two different formats. You can download a vector graphic and a PNG in suitable sizes. The background color of the thumbnails are for reference only, the provided graphics are transparent.

EPS (vector)	EPS (vector)	EPS (vector)	EPS (vector)
PNG (800px)	PNG (800px)	PNG (800px)	PNG (800px)
PNG (300px)	PNG (300px)	PNG (300px)	PNG (300px)
PNG (100px)	PNG (100px)	PNG (100px)	PNG (100px)

Beside the talks from Moritz Eysholdt (Patching Models and Evolving Meta Models), Simon Zambrovski (Playing with Eclipse Common Navigator Framework) and Markus Alexander Kuppe (Distributed OSGi, RFC 119 – The ECF way) there was a talk about ObjectTeams again. Marco Mosconi demonstrated how one can weave manually written code into generated GMF editors with an aspect-oriented approach. Nice!

Me talking about Xtext at the Eclipse DemoCamp in Hamburg

I had the opportunity to talk about Xtext in front of an audience that mostly had not seen it before. Playing with expectations and trying out some new ideas was great fun. Xtext becomes more stable and doing live presentations is no risk but a pleasure.

For those who do not want to miss the pizza recipe nor the class schedule DSL, you will find attached the slides. Peter’s photos and Simon’s album give a visual impression of the event. Also, please note that we have just published ready-to-use distributions with the current Xtext RC2 release. Nothing should stop you from implementing your very own grammar. And if you come up with a textual DSL to avoid wrong IDs in your plugin.xml, let me know

Downloads

• Slides at SlideShare (German)
• Eclipse SDK 3.5RC2 with Xtext 0.7RC2 (Linux-gtk)
• Eclipse SDK 3.5RC2 with Xtext 0.7RC2 (MacOS X-carbon)
• Eclipse SDK 3.5RC2 with Xtext 0.7RC2 (MacOS X-cocoa)
• Eclipse SDK 3.5RC2 with Xtext 0.7RC2 (Win32)

Whenever you have to prepare a digital show case, a presentation or simply try out a new programming library, the burnt IT-professional sticks to version control. And since the Internet is not yet omnipresent in trains, planes, secured environments or due to unpredictable events there is the demand for a locally installed system.

I am using Eclipse most of the development time so the choices are limited. And since I prefer SVN over CVS I was looking for a subversion server that can be used the Mac-ish way. Uli Kusterer put together an Apache server with the desired SVN capabilities built-in, tied it as a drop-installable application and called it MAS. It comes with a simple GUI that allows you to manage users to grant access to the repository that resides in your home directory (~/Library/Application Support/MAS). Download and drop it into you application directory. There’s nothing more to say.

For the last months MAS has done exactly what it was designed for. It supports me every time I want to put something under version control and stops serving when closing the application.

And tomorrow’s presentation at the Eclipse DemoCamp in Hamburg will benefit from it, too!

Figure 1: The Generation Gap Pattern

Separating generated files from manually written code is best practice for many reasons. It enables you to use version control wisely and makes the distinction between generated and manually written code easy. The Eclipse EMF Modeling Workflow Engine together with M2T Xpand allows you to accomplish this goal in different ways.

In this post, I will present three different approaches that share some common ideas. Each strategy uses a dedicated directory for generated class files whereas manually written subclasses are stored for themselves in a different directory.

General Directory Layout

Both sets of classes belong to the same package but reside in different source folders. Framework classes should be kept in yet another directory and might be placed in a package specific for the framework as seen in Figure 2.

Figure 2: Schematic directory layout of an Eclipse Java project

In Eclipse you can configure such a project structure by adding new source folders (New → Source Folder…) or by declaring ordinary folders as source folders in the project properties (Properties → Java Build Path → Source).

Please note that folder names such as src-generatedClasses are meant to be schematically and stand for a category of folders each. In real world projects you might have several source folders that contain generated artifacts and you might deal with many folders or even projects that contain manually written classes. In the following sections you will see how these categories of folders can be used in practice.

Generate Once

Peter describes a directory layout many Xtext users are familiar with. Generated artifacts go into a folder src-gen whereas manually written classes will be stored in a folder src-once. Each time you run the generator the content of folder src-gen will be purged and generated again whereas the the content of src-once will remain untouched.

Figure 3: Generate Once collects one-time generated artifacts for future editing

Since each model element A leads to two classes AbstractA and ConcreteA (Generation Gap Pattern) you can reduce the amount of manual work by generating the class ConcreteA if it does not exist, yet. During the next run of the generator the class ConcreteA won’t be generated again, hence the name “once”.

Configure an additional outlet in your EMF MWE file:

<component class="org.eclipse.emf.mwe.utils.DirectoryCleaner" directory="src-gen"/>
<component class="org.eclipse.xpand2.Generator">
   <metaModel idRef="mm">
   <expand value="MyTamplate::main FOR model">
   <outlet overwrite="true" path="src-gen">
   <outlet name="MANUAL" overwrite="false" path="src-once">
</component>

Using M2T Expand you can than refer to the outlet MANUAL where appropriate

«DEFINE ConcreteClass FOR Element»
   «FILE this.fileName() MANUAL»
   ...
«ENDDEFINE»

This approach works well in many scenarios but has its limits. As seen in Figure 3 problems arise whenever you delete or rename a model element. In these cases each concrete artifact at src-once that does not correspond to a model element anymore is abandoned and will remain with compile errors. This is desired for classes that hold manual code but is cumbersome for those that do not.

Figure 4: Generate Once in package explorer

For scenarios where a huge amount of generated classes is customized only in a few cases the “Generate Once” approach leads to unwanted manual refactoring effort including file movement. Life is getting worse when you are working with a complex folder structure instead of a single flat directory. Figure 4 might give you an idea of how things will look for growing models.

Conditional Generation 1 (with one gen-folder)

The following approach plays well when only a small subset of classes has to be extended with manual code. According to the Generation Gap Pattern for each model element A there is a generated class AbstractA as well as an concrete class ConcreteA. But in contrast to the “Generate Once” approach both files will be placed in the very same folder src-gen and therefore deleted and regenerated for each generator run.
There is one exception to this behavior. Whenever the generator finds a file ConcreteA in the folder src-man it skips the generation process for this particular file. This is how you introduce manual code.

Figure 5: Conditional Generation 1 reduces manual refactoring effort

At first glance this approach seems to be similar to the solution above. But when deleting or moving model elements this approach really pays off. Each concrete class that does not contain manual code will be deleted and regenerated. Therefore, when moving or deleting the model elements no additional manual work has to be done. Also, a quick look at src-man reveals any code that has been written manually.

Figure 6: Conditional Generation 1 in package explorer

To implement the desired behavior of the generator users of MWE can configure an outlet with a special veto strategy. Please note that the outlet MANUAL does not need to keep files (overwrite=”true”), they will be purged by the directory cleaner anyway.

<component class="org.eclipse.emf.mwe.utils.DirectoryCleaner" directory="src-gen"/>
<component class="org.eclipse.xpand2.Generator">
  <metaModel idRef="mm" />
  <expand value="MyTamplate::main FOR model"/>
  <outlet overwrite="true" path="src-gen" />
  <outlet name="MANUAL" overwrite="true" path="src-gen">
    <vetoStrategy class="your.package.CondGenVetoStrategy" path="src-man"/>
  </outlet>
</component>

Such a veto strategy would read like:

public class CondGenVetoStrategy implements VetoStrategy, VetoStrategy2 {

	private String path;

	public void setPath(String value) {
		path = value;
	}

	public String getPath() {
		return path;
	}

	public boolean hasVeto(FileHandle fileHandle) {
		URI fileToBeGenerated = fileHandle.getTargetFile().toURI();
		URI pathToGenerateInto = new File(fileHandle.getOutlet().getPath()).getAbsoluteFile().toURI();
		URI relativeFileName = pathToGenerateInto.relativize(fileToBeGenerated);
		File potentiallyExistingFile = new File(this.getPath(), relativeFileName.toString());

		return potentiallyExistingFile.exists();
	}

	public boolean hasVetoBeforeOpen(FileHandle handle) {
		return hasVeto(handle);
	}
}

oAW 4.x: VetoStrategy2 has been introduced with oAW 4.3.1.

Unfortunately, the advantages of this approach do not come for free: Compared to “Generate Once” it is more difficult to introduce manual code since it is harder to understand the needed steps. One has to create a concrete class in the src-man folder manually (or move it from src-gen and remove all comments that mark them as generated) where no class exists, yet. This might seem to be a no-brainer but can lead into trouble when defining a process for large projects. This is especially true for the unlikely case that you check-in generated code of src-gen.

Conditional Generation 2 (with two gen-folders)

A slighty different way that basically follows the same idea introduces yet another folder src-gencond.

Figure 7: Conditional Genration 2 lists classes that can implemented manually

As you can see in Figure 7 the generated artifacts are split into the folder src-gen where the abstract classes reside and the newly introduced folder src-gencond. The latter contains only the concrete classes that could be replaced by manually implemented classes. In contrast to the “Conditional Generation 1” approach the users are now able to find classes that can be augmented be manual implementations without any challenge. Users still have to move classes from src-gencond to src-man by hand but it is simpler to communicate the necessary steps.

Figure 8: Conditional Generation 2 in package explorer

As you can see in Figure 8 one can easily identify that there are two classes that could be implemented by hand. Such a folder structure can pay off when different groups of developers are dealing with a fairly large and scattered set of classes.

In order to realize “Conditional Generation 2″ you simply reconfigure the outlet MANUAL to write its output to src-gencond. Also, a second directory cleaner removes all files from this directory before code generation starts.

<component class="org.eclipse.emf.mwe.utils.DirectoryCleaner" directory="src-gen"/>
<component class="org.eclipse.emf.mwe.utils.DirectoryCleaner" directory="src-gencond"/>
<component class="org.eclipse.xpand2.Generator">
  <metaModel idRef="mm" />
  <expand value="MyTamplate::main FOR model"/>
  <outlet overwrite="true" path="src-gen" />
  <outlet name="MANUAL" overwrite="true" path="src-gencond">
    <vetoStrategy class="your.package.CondGenVetoStrategy" path="src-man"/>
  </outlet>
</component>

Comparison

Each of these solutions do their job in real world MDSD projects. Where projects with rather stable interfaces go with the “Generate Once” approach larger projects address growing maintenance effort with the “Conditional Generatation 1/2”  solution. The move from “Conditional Generatation 1” towards “Conditional Generatation 2” is rather trival and can smoothly be taken within a running project.

I’d be happy to read about your experience with these or different project setups.

By now I won’t call us Xtext experts but one thing is safe to say: Beyond the convincing basic functions Xtext does an awesome job when facing advanced topics.
(Falko Riemenschneider)

I am glad to see that TMF Xtext got rid of many strange issues oAW Xtext had when it comes to corner cases. And the extensibility with Google Guice will be of great value.
(Steffen Stundzig)

Please understand that I can neither publish the slides nor exercises of this workshop since it is material our customers pay for. We are still working on more content that will be publicly available. Meanwhile, if you are interested in Xtext the newsgroup is a valuable place to share experience and to delve into questions the documentation cannot answer.

For you itemis co-workers, read on at the intranet and download the material.

At the same time the Google Plug-in for Eclipse has been announced, too. Together with the 1.6 release of GWT there’s much to explore and a long and eagerly awaited feature comes true.

This is by far better than the fake of a Google App Engine for Fortran.

Sven and Jan had a talk about the upcoming release of TMF Xtext and shared their slides afterwards. During the event one could recognize some nice comments about Xtext at twitter.

But for me, the most interesting digital find is an interview with Wolfgang Neuhaus I stumbled across at Ian’s Blog. Without the demand for in-depth knowledge of specific tools Wolfgang introduces the ideas behind Xtext in a brief and precise way.

We know about bugs and missing features but with good cause I want to draw your attention to this release. Apart from the constantly improved core documentation we are beginning with documents like “Getting Started” or ”Migration from oAW Xtext“. The latter is far from being finished and will summarize the lessons we have learned together with our customers that have be been using TMF Xtext since M5 and earlier.

Xtext users might be glad to hear that the API of Xtext is reliable. To accomplish this goal we leverage the annotation @java.lang.Deprecated for parts of the API that won’t be supported in future. But more interesting is the newly introduced annotation @org.eclipse.xtext.Stable. An interface tagged this way is not truly stable itself since we might introduce new methods in future but the annotation might help you anyway. It directs you to an abstract class that you should derive from. Whenever a new method will be introduced in future this class will complement your work with a null implementation your can override as necessary (does anyone know how this pattern is called?).

Interface with @stable and corresponding abstract class

So, even if you won’t try out TMF Xtext at this stage this documentation material might give you a preview of what you can expect in June. Check out the New and Noteworthy Page for a general overview of this release.

Feedback is welcome through the news group and bugzillas.

Die abgeschlossene Hallen-Volleyball-Saison 2008/2009 sowie die berufsbedingte Einschränkung des Mannschaftstrainings berauben mich der wirkungsvollsten… Begründung eines weiteren Aufschiebens. Dazu gibt es mit der passenden iPhone-Anwendung und der persönlichen Trainingswebseite auch genug technisches Spielzeug, um die Motivation aufrecht zu erhalten. Ich werde über den Fortgang berichten.

• Tutorial (75 minutes, Tuesday morning)
  Challenges in DSL Design
  Sven Efftinge, Sebastian Zarnekow
• Case study (75 minutes, Tuesday afternoon)
  Mastering differentiated MDSD requirements at Deutsche Boerse AG
  Heiko Behrens, Karsten Thoms
• Hands-On (180 minutes, Thursday midday)
  Xtext Workshop
  Heiko Behrens Jan Köhnlein, Moritz Eysholdt, Sebastian Zarnekow

Apart from those, there’s a think tank that might strive oAW, too. Interested in Microsoft’s and JetBrains’ accompanists I am looking forward to the “Introduction to the Microsoft Oslo Modeling Platform” as well as “Language Definition, Extension and Composition with MPS”.

Inhaltlich etwas vollständiger aber weniger spektakulär, ein Aufklärungsvideo vom BMF. Während Jonathan nach einer kurzen Einführung und dem weiß aufleuchtendem Wendepunkt ein (auch farblich) pessimistisches Ende skizziert, geht es bei der simpleshow schon etwas freundlicher zu: Wer in Deutschland lebt und besonnen handelt hätte nichts zu befürchten. Einfach das liebe Geld in Staatsanleihen investieren und abwarten.

Leider erwecken die beiden Kurzfilme den Eindruck, dass die Finanzkrise nur Immobilienbesitzer oder Menschen mit größeren Spareinlagen betrifft. Die Übersicht der Tagesschau klärt in dieser Hinsicht auf. Für den besorgten Arbeitnehmer fasst der Focus allgemeine Ratschläge zusammen. Mein persönlicher Favorit gleich zu Beginn der Liste:

Halten Sie sich zurück mit apokalyptischen Prognosen. Das Unternehmen will und braucht Optimisten.

Klaro! Wikipedia bietet für den interessierten Leser mit dem Artikel “Finanzkrise ab 2007” dazu einen guten Startpunkt für weitere Recherchen. Bleibt zu hoffen, dass dieser Titel bald um eine weitere Jahreszahl zur Eingrenzung des Zeitraums ergänzt wird.