Small steps with big feet
Devoxx 2011 Impressions
Devoxx 2011 is over, and it was awesome. Finally, after having to spend the weekend with wife and kid (haven’t seen much of me the last week 
), I’ve found the time to write down some stuff. It was for me the sixth Devoxx, my first one being in 2006 – back when I was still a student and it was called Javapolis. So obviously I have some tradition with Devoxx, which grants me to say that (at least for me) it was one of the best editions ever. It may have to do with the fact I didn’t have a talk this year (Frederik had that honour), and I could enjoy the conference at its fullest. That said, time for a wrap-up!
Java == boring?
From a first glance at the Devoxx schedule it was clear that Java was not the first-class citizen it used to be on Devoxx. Dynamic languages, Android and HTML 5 were this years favourites. And, in my opinion, the organisators have decided wisely. We’re past the time that every new Spring, Hibernate or JBoss version drive cool and innovative features. EE6 and its features are well told and understood by now. UI frameworks have come and gone (byebye, JSF!). If you think about it, what ‘big hot item’ has happened in the last year in Java land? … Exactly.
And that in itself is not a bad thing. Java is as mainstream as mainstream can get. Solid, stable and here to stay for a long time (almost sound like Cobol … ). Sure, there is plenty of opportunities and work to do if you’re a Java developer. But we have to admit that we’re not amongst the hottest of the hottest these days (and probably have been like that since the advent of Ruby on Rails ). Which is why some polyglotism and peeking around other technologies can’t hurt, if you’d ask me.
University days
I attended Devoxx during both Uni and Conference days. For me personally, I found the Conference sessions wildly more interesting than the Uni talks. Three hour talks are just not my cup of tea. There just too much technical depth and information in these talks. I rather read a book on my own pace than trying for three hours to frantically follow every slide of the talk. Lessons learned for next year.
One exception: I really liked the Android Jumpstart talk by Lars Vogel. I have some IOS development experience, and seeing how straightforward Android development is, was interesting to say at least.
Keynote: next year not Oracle, pretty please?
I think everybody wholeheartedly agreed that the keynote(s) on Wednesday by Oracle were boring as hell. I had high expectations when the first Oracle guy started with the obligatory Oracle Disclaimer, but invited the audience to find the spelling mistakes he added on purpose. But it was downhill from there. Nothing new in the presentations, slides obviously originating from sales and marketing, frantically avoiding the ‘Android’ word (J2ME will be and important focus in the future … uuuh yeah, right!).
I mean, these guys get a golden plated chance to get on the stage and show the tech audience that they rock as being the new steward of Java… Anyway, enough words written on this topic. The fact I saw several people sleeping in their seats speaks for itself.
Keynote: but Google can certainly return!
The Android keynote by Tim Bray on Thursday luckily was of a different kind. Great speaker (been following his blog since I discovered Ruby on Rails years ago), humorous, a new feature with examples here and there (I’m an IPhone guy, but hell Android sure has some sweet stuff up it’s sleaves!) and a real ‘call-to-action’ at the end (got the whole room very, very silent). I was in doubt to get up early again to go to the keynote after the debacle of the day before, but it sure was worth it.
On a sidenote: Stephan’s keynote (this year announcing Devoxx France!) was as good as ever. He can definitely return next year
Sessions: too much choice!
The hardest part about Devoxx is the choice. With seven talks going on in parallel, on has to choose. And sometimes I had three sessions picked at the same time… damn! Luckily, all talks should be on Parleys by Christmas (and every Devoxx attendee gets access to it!).
I saw plenty sessions during Devoxx, but some of them really stood out:
Activiti + Vaadin, A match made in heaven
No suprise here My fellow Activist Frederik did a great co-op presentation with the Vaadin guys. Both Activiti and Vaadin are of course enormously cool frameworks, so the combination surely gives some firework. There were some nice (new) features in the talk too, which they kept secret until the talk (like the annotations to match a form with a Vaadin view). Someone in the audience taped the whole talk and has put in on Youtube. Enjoy!
Java: The Good, the Bad, and the Ugly Parts by Joshua Bloch
As Joshua Bloch his sessions tend to be the most popular ones (last year, I could’t get in), I made sure to be good in time. The content of the talk was an overview of basically JDK 1.0, and what was in there that helped Java to be where it is today, and what might have hindered it. As you would expect from him, some nice puzzlers thrown in between. One of the best speakers out there, and really knows his stuff.
PhoneGap for Hybrid App Development by Brian LeRoux
I only knew the idea behind PhoneGap, so this session was exellent to soak up some information. Brian is an awesome speaker, typical start-up attitude with the obligatory cursing and quotes to remember. Altough his demo’s (except one) didn’t work due to his Mac not seeing his Android, followed by cursing adb and all that is holy, I understood the goal and value of PhoneGap. I was really impressed by PhoneGap Build, a cloud environment where you upload your HTML and Javascript, and it gets compiled to every platform you wish (even Blackberry). The demo went well this time, and after uploading his example html, he could just scan the QR code on his screen and the app got installed on his phone. Sweet!
People who work with me in real-life, know that I’m fan of blaming others for yak shaving. Brian’s slide on ‘serious business time’ couldn’t have said it better
Meh! It’s only cross site scripting what’s the big deal? by Cambell Murray
I had expected a technical talk, but we rather got juicy examples and stories about customers (anonymous of course) on security bugs that lead to huge problems. Really great speaker. It was as if he was just was at a bar and talking while having a beer. It was a clear eye-opener that there is a world outside our comfortable Java code where hackers and criminal entities are extremely inventive and do stuff which we as ‘normal’ developers would never have tought of.
Rules for Good UI Design by Joe Nuxoll
This session was placed in one of the smaller rooms, but this quickly proved to be a mistake. In no time the room was complety packed, and people sat everywhere they could. This is really a good sign that developers are understanding the need of UI design.
Joe is an UI designer for the Tesla S interface who used to work for Apple (which might have helped for the session’s popularity), and the examples were of course chosen from that background. The first part of the talk was a tid boring (but I already read quite a bit on the topic), but the second part was full of examples and tips.
The audience size definitely proves that Java Developers are evolving too.
WWW: World Wide Wait? A Performance Comparison of Java Web Frameworks by Stijn Van den Enden (and others)
I know Stijn personally, so choosing his session was a no-brainer. Again, the topic proved to lure a lot of people, and the room was very fast sold out. The talk took the session of Matt Raible of last year on Devoxx as starting point, but added real numbers and more importantly, real math to the table. Five frameworks (GWT, Wicket, JSF -2 implementations- and Vaadin) were put to the performance test. The performance architecture was thorougly explained, as were the measurment calculations/validations and potential pitfalls. Very profesionally brought.
Big winner of this test was GWT, albeit needing most of coding compared to the other. My framework of choice, Vaadin, did very well, and in a chat with Stijn later on he also expressed that the rapid development of Vaadin makes it a framework to consider.
JSF was the big loser of the day (at least the MyFaces impl, the Mojarra was better), and proved to scale much, much worse than the others. I had a French (or was it Spanish) project lead sitting next to me, who had expected validation for his ‘choosing the standard’. His sighs and painful yelps with every new graph shown on screen almost made me have compassion.
The networking
No, I’m not talking about the Wifi (which was horrible), but rather meeting people. As every past edition, Devoxx is a great way to meet up with many people of the Java eco-system. I met a lot of old friend, ex-collegues and met some new people. That alone is worth the trip to Antwerp.
Devoxx 2012
Devoxx 2011 was great in every way, and for me it still is the best conference out there – period. Looking forward to next year!
Activiti KickStart moved to GitHub
As of Activiti 5.7, KickStart is no longer part of the ‘official’ Activiti dsitribution.
KickStart has always been a prototype, which I wrapped up in a short amount of time to prove the point that creating simple BPMN 2.0 compliant processes can be done with a very simple UI. However, as we are focussing our efforts in Activiti in building and maintaining the best workflow/BPMN2.0 engine, KickStart doesn’t fit in that picture.
As it would be a waste to just throw away the code, I moved the KickStart code to GitHub, url is https://github.com/jbarrez/Activiti-KickStart. I’m sure that some people will find the UI to JAXB to executable BPMN 2.0 processes useful. I do plan to spend free time on it in the future, for practising my coding kata’s . Anyone interested in contributing is surely welcome!
Screencast: New Activiti Explorer
One of the highlights of the latest release of Activiti, is absolutely the new revamped (= redesigned and rewritten) Activiti Explorer app. In the screencast below, I’ll give a quick tour of the app.
Activiti Explorer (The Next Generation) has all the features of the previous version. Some new features include (but not limited to) support for
- Different types of task lists
- Event stream
- Comments
- Standalone tasks
- Subtasks
- Attach any content to a task
- Process instance view
- Administration (previously found in Activiti Probe)
- Profiles
More info & screenshots can be found in the Activiti userguide.
For the tech people: the app has been completely rewritten using Vaadin (you might have noticed we’re big fans). The source can be found in the Activiti svn repo.
Screencast
Make sure to set the screen full-size, and change to 720HD (Youtube doesnt allow embedding it as HD and changing the size at the same time – sorry!)
Cool new features in Activiti Designer
Tijs Rademakers (already 2 months full-time Activiti team member now … time sure flies!) posted on his blog an overview of some new features in the latest Activiti Eclipse Designer release. All features are demonstrated with a short movie, so it’s all very digestable 
.
I’m a huuuuuge fan of the quick edit feaure! This is really a productivity booster.
How to: Vaadin add-ons and Maven
Introduction
One (of the many) thing I like about Vaadin, is its community of ‘add-ons’ to the Vaadin framework – what they call the Vaadin Directory. An ‘add-on’ is a community-contributed addition to the framework, and can be anything from for example a new client-side widget to a Lazy loading container for a data table. Something similar I would definitely like to see for Activiti!
Vaadin widgets are basically precompiled GWT widgets. GWT widgets on itself are Java classes, but the GWT compiler compiles them to Javascript that works accross all browser. So, when you want to use a certain add-on (that has new client-side visuals) in your Vaadin webapp, you will have to compile them yourself since you must include the new Javascript in your webapp.
If you are using the Vaadin Eclipse plugin, all is happy and fine. Just add the add-on jar to your project, and the plugin autodetects and compiles the new widgets. However, when your webapp is built using Maven, it’s not that simple. But throwing out Maven and manually copying all your dependency jars is not necessary at all. It’s 2011 after all.
The default way of doing the GWT compilation in Maven is, in my opinion, not efficient. So let me guide you through what setup works the best for me and how I tweaked the Maven pom.xml.
For the impatient-ones: check the source on github: https://github.com/jbarrez/vaadin-mvn-addon
Creating a new Vaadin webapp with Maven
This step is well-documented, just check the Vaadin wiki.
Short version: use following archetype:
mvn archetype:generate -DarchetypeGroupId=com.vaadin-DarchetypeArtifactId=vaadin-archetype-clean -DarchetypeVersion=6.5.6 -DgroupId=com.jorambarrez -DartifactId=vaadin-mvn-addon -Dversion=1.0 -Dpackaging=war
Add the add-on
In this example webapp, I’m going to use two cool Vaadin add-ons:
- Paperstack: a container that allows to display components as pages of a book
- Refresher: a client side component that polls the server for UI changes
Both add-ons have new client side widgets, so a run through the GWT compiler is definitely needed.
Tweak pom.xml
Open up the pom.xml. The archetype already generated all you need to work with custom add-ons. Look for commented sections, and just uncomment them. That’s all there is.
Create the webapp
The following Vaadin webapp shows a simple use of these two components. We’ll just display ‘Activiti’, with each character on a new page of the paperstack component. We also have a button, that will auto-flip through the pages using the Refresher component and a server-side thread:
public class MyVaadinApplication extends Application {
private static final String DISPLAYED_WORD = "ACTIVITI";
private Window window;
private Refresher refresher;
private Button goButton;
private PaperStack paperStack;
@Override
public void init() {
window = new Window("My Vaadin Application");
setMainWindow(window);
initGoButton();
initPaperStack();
}
private void initGoButton() {
goButton = new Button("Flip to the end");
window.addComponent(goButton);
goButton.addListener(new ClickListener() {
public void buttonClick(ClickEvent event) {
goButton.setEnabled(false);
startRefresher();
startPageFlipThread();
}
});
}
private void startRefresher() {
refresher = new Refresher();
window.addComponent(refresher);
refresher.setRefreshInterval(100L);
}
private void startPageFlipThread() {
Thread thread = new Thread(new Runnable() {
public void run() {
goButton.setEnabled(false);
int nrOfUpdates = DISPLAYED_WORD.length() - 1;
while (nrOfUpdates >= 0) {
paperStack.navigate(true);
nrOfUpdates--;
try {
Thread.sleep(2000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// Remove refresher when done (for performance)
goButton.setEnabled(true);
window.removeComponent(refresher);
refresher = null;
}
});
thread.start();
}
private void initPaperStack() {
paperStack = new PaperStack();
window.addComponent(paperStack);
for (int i=0; i<DISPLAYED_WORD.length(); i++) {
VerticalLayout verticalLayout = new VerticalLayout();
verticalLayout.setSizeFull();
paperStack.addComponent(verticalLayout);
// Quick-hack CSS since I'm to lazy to define a styles.css
Label label = new Label("<div style=\"text-align:center;color:blue;font-weight:bold;font-size:100px;text-shadow: 5px 5px 0px #eee, 7px 7px 0px #707070;\">" + DISPLAYED_WORD.charAt(i) + "</div>", Label.CONTENT_XHTML);
label.setWidth(100, Label.UNITS_PERCENTAGE);
verticalLayout.addComponent(label);
verticalLayout.setComponentAlignment(label, Alignment.MIDDLE_CENTER);
}
}
Tweak web.xml
To make Vaadin aware of the custom add-ons, add following lines to the Vaadin Application Servlet:
<init-param> <param-name>widgetset</param-name> <param-value>com.jorambarrez.CustomWidgetset</param-value> </init-param>
Also add a file ‘CustomWidgetset.gwt.xml’ in the package com.jorambarrez (matching whatever you have put in the web.xml). Just copy the following lines, and don’t worry about putting the add-on GWT descriptors there (which would be logical), the maven plugins will find them automatically in the add-on jars.
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE module PUBLIC
"-//Google Inc.//DTD Google Web Toolkit 1.7.0//EN"
"http://google-web-toolkit.googlecode.com/svn/tags/1.7.0/distro-source/core/src/gwt-module.dtd">
<module>
<inherits name="com.vaadin.terminal.gwt.DefaultWidgetSet" />
</module>
Run the webapp
Go to your project, and execute following command:
mvn clean package jetty:run
This starts up a Jetty webserver and deploys our webapp. You should now be able to play around with the webapp.
The problem
When running the previous command, you’ll should see the GWT compiler kicking in and compiling the custom widget. The problem is, the GWT compiler does take its time to do its magic (1.30 minutes on my machine, while simply starting Jetty takes 5 seconds).
I’m not going to sit and watch the GWT compiler sprinkling pixie dust over my add-ons every frick’n time when I want to run my app. Sure JRebel, could help out a lot here, but it should most definitely not be necessary to have my widgets compiled every time. After all, I’m not changing these add-ons at-all, right.
Tweaking pom.xml (The Sequel)
So we just learned that the default pom.xml generated by the Vaadin archetype isn’t friendly when it comes to add-ons. If you take a look at the configuration of the GWT compiler plugin, you’ll notice that the compiled widgets are added to the target folder, and not in the sources of your project:
<webappDirectory>${project.build.directory}/${project.build.finalName}/VAADIN/widgetsets</webappDirectory>
If we change that to our source folder:
<webappDirectory>src/main/webapp/VAADIN/widgetsets</webappDirectory>
the result of the GWT compilation is put in the source of my webapp. This also means I can just check them in together with the rest of my webapp.
The only thing we now need to do, is to make sure we don’t recompile the widgets on every run. I’ve chosen to simply put it in a profile as follows:
<profiles>
<profile>
<id>compile-widgetset</id>
<build>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>gwt-maven-plugin</artifactId>
....
Whenever I now add a new add-on to the project, I now run the following command:
mvn -Pcompile-widgetset clean compile
and it will compile all add-ons and put the result in my source folders. Running the Jetty webserver as shown above, will now just copy these sources to the war file and boot time is reduced to a minumum again (5 seconds here).
Source
The whole webapp as described in the above steps in fully available on GitHub: https://github.com/jbarrez/vaadin-mvn-addon
Conclusion
Using add-ons with Maven is not that hard, all of that is well-documented (as anything in Vaadin). However, the Maven archetype generates a Maven configuration that isn’t that efficient since it recompiles the add-on widgets on every run. The above steps show how to tweak the config to make it more suitable for real rapid development!
Any comments or improvements are welcome of course!
Screencast: from zero to executable process with the Activiti Designer
The Activiti 5.2 release contained tons of new features. One component that has been doing major leaps with every release, is the the Activiti Designer plugin for Eclipse. In the latest release, both BPMN 2.0 ‘diagram interchange’ and BPMN 2.0 import have been added. The first one enables that your process looks exactly the same on every BPMN 2.0 compliant editor. The second one allows to import any BPMN 2.0 compatible process and enhance it in the comfortable environment of Eclipse. Furthermore, the Activiti Designer is completely contributed by four Dutch guys in their free time (and two of them are writing the Activiti book)… yessir, this is one piece of open-source awesomeness.
In the following screencast I demonstrate how you can model a BPMN 2.0 process using the Activiti Designer, how you can easily generate a skeleton unit test from that model and finally how you get it running in Activiti explorer. And that all in less than 10 minutes! Enjoy.
Be sure to set the video to full screen to enjoy it to the fullest
Screencast: process instance visualisation in Activiti 5.2
Another month, another Activiti release! Read all about the newest and best release (so far of course) on Tom’s blog.
One feature that many people have asked for in the past is added to this release: it is now possible to graphically visualize a process instance and show which steps exactly are currently active. I’ve made a short screencast demonstrating this new feature.
Many thanks go to Maciek Próchniak, who contributed this feature. He needed it for an Activiti demo and decided to implement it. That’s open source power at work!
Great technical in-depth blogpost about Activiti internals
Just wanted to give the blogpost of Tomasz Nurkiewicz the exposure it deserves.It is a well-written, in-depth accurate post describing some of the internal workings of Activiti, without forgetting to throw in a funny line here and there. On top of that, you can download the source code of everything he explains at the end of the post!
Furthermore, if you are interested in more articles, screencasts and presentations about Activiti, all are bundled on the following page: http://docs.codehaus.org/display/ACT/Presentations+and+Articles. Feel free to add blogs there, if you think they belong there.
Getting started with Activiti … in less than a minute
At Activiti, we know that first impressions matter. Nowadays, and certainly in the software world, if you don’t convince people within the first ten minutes after download, huge chance that your product ends up in the trash bin.
With Activiti we have set ourselves a more challenging goal. If we can’t convince people in the first minute after download, we’re doing something wrong.
So no excuses on not having enough time to try out Activiti: getting started with Activiti takes only one minute of your time! Or even less, depending on your machine speed. That’s quite a fresh idea, isn’t it, if you know what hassle it is to get some competitor products running .
To prove we’re serious, the following screencast shows the one minute after downloading Activiti from the website, and running the demo setup, which installs a complete Activiti environment for you.
If you want to do this yourself, just follow these steps:
- Download Activiti from Activiti.org
- Unzip the downloaded file
- Open a terminal window and navigate to the setup folder inside the unzipped folder
- Type ant demo.start and hit enter
And that’s all there is to it!
BPMN 2.0 officially released
It certainly took a while to ‘finalize’ the release of the BPMN 2.0, but the folks at OMG have tagged BPMN version 2.0 as final !
What does this mean for you and Activiti?
Absolutely nothing, since Activiti already implements the final specification since the 5.0.alpha4 release. The XSD, constructs, sematics etc haven’t changed one bit. Activiti has been and will always be on the front of BPM advancement.
My gut feeling is that very soon you will see many vendors coming out with their BPMN 2.0 support (which might be a reason for the delay of the ‘final tag’ of the spec, according to some of the rumors )
Thanks Camunda for notifying me of this news!