vaadin.com

Vaadin 7 certification goes online

2013-05-21T12:51:25Z

We have a long awaited announcement to make: Vaadin 7 developer certification is finally live at vaadin.com. Starting from today, you can validate your Vaadin 7 skills by taking an online exam through the Vaadin Pro Account. Vaadin certification helps you communicate the skills and expertise in Java web development with Vaadin and as it says officially: “As a Vaadin 7 Certified developer you should have the skills and knowledge to quickly build and deploy web applications to any Java EE application server using Vaadin technology.”

The exam itself is a multiple choice question test, and you have to get 60% right in order to pass it. Once successfully passed the exam, you will be awarded a certificate to show others the level of your expertise in Vaadin 7. For those already building Vaadin 7 applications, it should be no problem to pass the exam. And in case you fail the first time you can retake the exam after 30 days of more experience.

Final exams for the Vaadin Trainings

At the same time we are introducing final exams for the official Fundamentals and Advanced Vaadin trainings. They run in the same exam system and like the certification exam, the Vaadin Trainings final exams are time limited and consist of multiple choice questions. They are just a little shorter and focus on the training content.

Knowledge base end-of-life

Overall, we want that people build good web applications with Vaadin. This is why introducing the online developer certification is actually a more profound change in Vaadin expertise management. In the future, we are focusing on certification quality and at the same time ending the Vaadin Knowledge Base service in Pro Account.

Our open-source forum has always been a good channel for sharing information and while the community grows, it is getting better and better. We want to encourage this and allow those who want to be professional Vaadin developers to have better ways of showing it.

The Knowledge Base is still available until the end of 2013, but after that we will not be maintaining it any more.

Prepare for the certification exam

So what should you do to prepare for the certification?

Most importantly, the certification is based on the Book of Vaadin and therefore it is best to start with. Learn the basic concepts of Vaadin and try to learn how the component architecture works.

Further, our official trainings are a very good way to concentrate on the topic and to learn most of the things needed for certification. You are not required to attend a training before certification, but as you know, hands-on sessions are a quick way to learn something. Check the training schedule for nearby training sessions.

The final step is to get yourself a Vaadin Pro Account. You cannot take the certification exam with an evaluation account, so you must have at least one month of active subscription. To help you get certified we are now offering the certification together with 6 months of Pro Account subscription for $300 using the discount code "MAYCERT". The code is valid for two weeks, but after that you still have plenty of time to take the certification exam.

Join us for a certification webinar

Next week we are also going to arrange a webinar on Vaadin Certification. It is intended to help you understand how to take the exam and how to prepare for it. And maybe give you some tips on how to really pass it. This is 30th of May at 15.00 CEST. Enroll here.

Vaadin Development Team Update 05/2013

2013-05-17T12:45:55Z

While we're still working at full steam, there has not been so much visible progress to highlight as we have mostly been fixing important but not spectacular bugs. We did release Vaadin 7.1 beta 1, but that was already covered in my previous update as well as in a separate blog post. We released 7.0.5 with various bugfixes a couple of weeks ago while 6.8.11 and 7.0.6 are being released as this is written.

One change worth mentioning in 6.8.11 and 7.0.6 and also coming for 7.1.0 is a fix to cope with some changed API in the upcoming Liferay 6.2 release. Provided the API does not change any more, Vaadin should be able to claim support for Liferay 6.2 the day it is released.

Looking into the immediate future, we're mainly focusing on fixing as many bugs as possible for upcoming maintenance releases. While pursuing beta 1, the backlog of important bugfixes to already released versions got slightly out of control but it is now once again heading in the right direction.

The final 7.1.0 version is of course also waiting around the corner. It should not bring any surprises compared with beta 1 unless a reduced defect count is surprising to you. There will not be any more 7.0.x versions once 7.1.0 has been released. Based on the current schedule, this would mean that 7.0.7 will be the final 7.0.x version as both should be done at roughly the same time. Maintenance updates to 6.8.x will still continue as before, i.e. with a new maintenance version every month.

The slightly more distant future holds various topics that we will research and hopefully incorporate into upcoming releases. Perhaps the most “interesting” of those topics is to discover a sensible way of doing data binding in client-side code (with automatic binding to a server-side data source) and then rewrite Table and ComboBox from scratch to use that API and also to provide their own respective client-side APIs so that the widgets can be used without a corresponding server-side component. Suddenly, other topics such as support for cross-site embedding and a refactored Visual Editor start to seem trivial.

That's all for today. Happy coding until the next update. We would especially like to hear your feedback from trying out Vaadin 7.1.0 beta 1!

You had opinions on Directory

2013-05-14T07:05:55Z

In Finland, we default to “no feedback is good feedback” – You usually don’t get positive feedback, since everyone assumes everything works great, that perfection is status quo. When we had a questionnaire about Directory, imagine my surprise when many of you actually took the time to take the questionnaire, just to say how much you liked Directory. There might be better ways to start off days, but I can’t come up with one off the top of my head.

Before going into analyzing the feedback, I want to point out some interesting things that popped right out of the survey, as we also asked for some general statistics on how and where you use Vaadin.

Here’s the first surprise. We’ve always assumed that Eclipse is the most popular IDE, and it’s nice to see data to support your assumptions. But that wasn’t the surprise. The surprise was with the second most popular IDE. We thought it being NetBeans, mostly because it’s free. But IntelliJ IDEA seems to have twice the following of NetBeans among Directory users. It’s also a third of Eclipse’s popularity, which is pretty significant. This seems to indicate that we need to make sure that IDEA continues to be well supported.

Another interesting piece statistics that wasn’t as much of a surprise as a confirmation of our vision: About 80% of people use some kind of dependency management, and 70% use the means Directory (and of course Vaadin) has explicit support for. This sounds like it might be a good idea to swap the emphasis on Directory download methods: Make Maven/Ivy downloads the default retrieval means. Nevertheless, 22% is enough of a user base to justify the continuation of the file download feature.

Musing on the future

As nice as this was, we were actually hunting for areas for improvement in our service, and that requires what some might regard as “negative feedback.” I’m very pleased to know that you’re interested in the very same improvements that we’ve already spent some napkins on, for planning purposes.

Reading through the responses I have here, it seems like some, if not most, are content with how Directory works today. Which is awfully nice of you, but we aren’t content. Thankfully there were people who see areas to improve in, and they gave their insights on what they would like to see in the future. There’s no single trend or feature to grab a hold of, but the general feeling seems to be that Directory has grown out of its initial parameters and use cases. We feel the same.

The browsing of Directory is something that needs to be addressed. Currently, a given add-on is too easy to drown in the volume, and it’s still too easy for popular add-ons to remain in the spotlight. Interesting and useful add-ons that don’t have a great initial following are in great danger to simply slip through the cracks into obscurity.

All these things are what we’ve felt like a long time, and I find that the feedback you’ve given us are on the same lines of thought. We currently have no actual plans on this, but I reveal that we’re paving way in our schedules for the time required to make new designs for Directory and the implementation thereafter. I even heard rumors about a future behind-the-scenes blog series about that entire ordeal...

New Book - Vaadin 7 Cookbook

2013-05-07T11:33:56Z

At the end of April, we were happy to hear that a third book on Vaadin has been finalized and published (not counting Book of Vaadin, of course). The authors Jaroslav Holaň and Ondřej Kvasnovský have done an awesome job with the Vaadin 7 Cookbook.

“Cookbook” is indeed the perfect word to describe this book. It is divided into 12 chapters, each with its own theme (think “Starters”, “Meat”, “Fish”, ...). It contains a lot of small things that could be useful in an application, and then the ways and detailed steps to get there - the recipe itself. As the book contains a lot of code, and explanations for them, it’s very convenient that you can download all code from the book’s webpage. Having the code locally to tinker with is invaluable, and you get to avoid problems like copying things wrong by hand.

In addition to aiding the reader on using features that come with the framework itself, the book also dives into various technologies surrounding Vaadin and Java. Many examples use add-ons from Vaadin Directory, and using Vaadin with technologies like Grails is also covered.

If I would be a beginner with Vaadin, this is the kind of book I’d like to study - a lot of examples that do a single thing, and everything regarding to that one thing is well explained. With the example code downloaded and in my IDE, I’d be free to tinker around, and learn in the process - that’s how I learn new things, not by reading theoretical ramblings regarding things and stuff.

Check out Packt publishing’s website for this book to get a sneak peek into this book, and also links to various online retailers to get your hands on this. The book is available in both physical and ebook forms.

Vaadin 7.1 Beta out now

2013-05-06T10:47:45Z

What a nice way to start a new week. The Vaadin build process was successfully completed on Friday and we have now a new minor (beta) release: Vaadin 7.1 Beta1 is available in Maven Central and on the download page.

Those of you who have been following Vaadin development lately already know that this is most prominently about the server-push. It is the feature to make your applications more server-driven than before - real-time, background processing, asynchronous, and more collaborative.

Even if you are not interested in creating asynchronous server-driven applications, there are still new features in 7.1 that might be interesting to you. The Calendar add-on has now been integrated into the core framework and there is now Page.getCurrent().getStyles() for injecting your own CSS for the components, a completely new debug window, and the possibility to optimize widgetset size. For more details, please consult the release notes for the beta release here.

Your first push application

From a programming point of view, one should keep in mind that writing multithreaded applications is also a bit more complicated than writing single user, single threaded ones. We have tried to make it easier by providing some API for this. A couple of important pointers:

XHR (or HTTP request-response) is still the default communication channel and to use server push you must enable it first. Take a look at the tutorial here: https://vaadin.com/wiki/-/wiki/Main/Enabling%20server%20push
Lock the UI instance when updating the content. There is UI.access(Runnable) method for doing this. Just remember to minimize the work done inside this Runnable to avoid performance problems.
ThreadPoolExecutor.submit(Runnable) is a simple way to run asynchronous tasks, but different Java EE servers may provide other Thread pooling mechanisms.
Vaadin 7 leverages Java asserts to give you some development time information. This is helpful in finding logical mistakes like thread deadlocks, etc. Use the command line option -ea to enable asserts in your JVM.
The push implementation is based on Atmosphere framework and you can find compatibility information here.

We still have some known limitations, but Vaadin 7.1 Beta should now be a good starting point for development of applications that need real-time updates fired from the server. Of course, your imagination is the limit, but to help you get started, here are some push-enabled Vaadin application prototypes we have made previously:

Chat application with all the bells and whistles (like CDI, JMS, try it here)
Updating the HTML5 canvas from server-side in Vaadin Tetris (also play here)
Two player real-time card game (ask a friend to play here)
Shared multi-user Calendar sample application (try here)

And surely there is more to come soon...

Responsive design

2013-05-03T12:12:13Z

We’re releasing a preview version of an add-on, simply called Vaadin Responsive, for making responsive design possible in Vaadin applications. With this early version, we hope to gather feedback about responsive design in general, what wishes and needs you have, and to improve the add-on from there. It provides us with a good proving ground for such features, and we will consider adding them directly to the core framework if they prove to be useful for many.

What is responsive design

If you’ve been following the web development community during the last few years, you’ve probably encountered the term “responsive web design” (RWD). It is a web design approach aimed at crafting sites to provide an optimal viewing experience – easy reading and navigation with a minimum of resizing, panning, and scrolling – across a wide range of devices (from desktop computer monitors to mobile phones) (from Wikipedia). While it is more related to content heavy websites than web apps, the same principles can be applied to applications as well.

Some of you have asked how to do responsive layouts with Vaadin, but we haven’t had any proper answers. Of course, it has been possible to use CSS Media Queries to adapt your layouts to different browser window sizes, but they don’t work in Internet Explorer 8, which is somewhat problematic for Vaadin apps (you could argue IE8 doesn’t need responsive layouts, but let’s not get into that now). Another issue is that media queries (viewport dimensions specifically) are relative to the whole browser window size, making it difficult to use them for sub-parts of your applications. For instance, you can’t know the size of a side of a split panel, since the user can drag the splitter into different positions without the browser window size changing.

What it does

Check out a quick demo of the add-on. It’s a bit contrived, but shows the functionality: mainly how different parts of the UI adapt to changing widths of their container.

The Vaadin Responsive is an extension that can be added to any component or UI, making that particular component/UI instance react to its width and height changes in the browser. You can then define width and height ranges (something that web designers like to call breakpoints, but that term is a bit misleading in the tradional developer context) in CSS and adjust the styles to suit those particular ranges.

This allows you for instance to change font sizes, margins etc. depending on the size of a component, or to arrange the contents of a layout from horizontal to vertical when there is not enough room to show it horizontally.

That’s all it does now, but it could for instance communicate those same ranges back to the server and tell when each of them is active, allowing the developer to adjust more than just the styling of the component. That’s why we need your feedback, so we can decide what functionalities are the most important.

How to use it

You can download the first preview version of the add-on from the Directory. If you need help using add-ons, here are the instructions.

A simple use example:

Java

CssLayout layout = new CssLayout();
// The responsive component needs to have 100% width for 
// width-ranges to work, and similarly for height-ranges
layout.setSizeFull();

// Set a style name to target just this instance
layout.addStyleName("my-responsive-layout");

// Add the responsive functionality to the layout
new Responsive(layout);

CSS

.my-responsive-layout[width-range~="0-800px"] {
  // Styles for 0-800px width
}

.my-responsive-layout[width-range~="801px-"] {
  // Styles for 801px and wider
}

.my-responsive-layout[height-range~="0-100px"] {
  // Styles for 0-100px height
}

How to help

As said, we’re looking for feedback for this early release. We need you to take it for a spin and tell us what works and what doesn’t, what use cases you have in mind for it and how well it currently handles them. And since it’s just an extension, it is easy to just try it out and remove it if you don’t find it necessary or suitable.

The source code is living in GitHub, and you can report any issues and suggestions there as well. Leave a comment here on the blog if you wish, we’re looking forward to hearing your opinions!

50 000 is a huge number

2013-04-25T13:29:22Z

The community has always been important to us, and continues to be so. We do our best to provide interesting technologies, articles and other insights for you. Apparently we’ve done some things right, since today marks the day when we got our 50 000th registered user on vaadin.com. Funnily enough, it coincides pretty perfectly with our 50 000th forum post, from about a week ago.

We’re quite excited about this number of members. Having watched how the community has grown from its infancy, you - the community - have always been helpful, friendly and exceptionally active. 50k is quite a milestone, and we see this as exactly that. A milestone.

While this number represents only a fraction of the size of our entire community, it gives an indication of the most active developers. More community members lead to more information on our forums, quicker answers to your questions and better questions for the archives in the future. Not only do the forums grow, but this also means more traffic to Directory; more add-ons, better feedback, more contributions...

We’re not stopping at 50k, so all this will just snowball into even more of everything. Our job is to make everything about Vaadin as awesome as possible. And we can only hope that you continue to enjoy what we do, enjoy what you do for each other, and enjoy to do things for others.

Vaadin Development Team Update 04/2013

2013-04-16T13:07:13Z

Let’s start with the bad news: We have chosen to postpone Vaadin 7.1 beta 1 to the beginning of May with a stable release coming a month later. The main reason for this delay is that we want to tweak the push support by adding a couple of small features that we initially imagined we would not need and also by ensuring that we understand how scalability and compatibility with different servers and browsers work out if push is enabled. We apologize for once again pushing deadlines ahead while we struggle with finding a way of inventing schedules that have a chance of surviving the inevitable collision with reality.

The corresponding good news is that basically everything else in the 7.1 branch should be ready for a beta release. I will not bore you by listing all the new features as those are already listed in the updated release notes. I would, however, like to highlight my personal favorite (even though I didn’t even implement it myself): the improved structure and visuals of the debug window. This new pearl will eventually be easily extendable just by dropping an add-on jar on the classpath and recompiling the widgetset. At this point we are still holding on to that API until we have had some time to ensure we are understanding all the requirements, but stay tuned for updates in upcoming minor releases.

In other news, Vaadin 7.0.4 and 6.8.10 have been released, fixing a critical security issue in portlet environments as well as some smaller issues. The last release announcement for this time is Vaadin CDI 1.0.0 alpha1. If you already know how to use CDI and want to use it together with Vaadin, please have a look. Please keep in mind that this is still an alpha release so there might be interesting bugs hiding under the surface and the documentation might not be tuned for normal users that don’t eat differences between different scopes for breakfast.

Quickly ahead to the future: We will be adding the final touches to Vaadin 7.1.0 beta 1 and fix bugs for Vaadin 6.8.x and Vaadin 7.0.x maintenance versions. That’s all. Yes, seriously. We have lots of newly discovered or previously overlooked issues to keep us busy right now.

Vaadin Directory celebrates 3 years

2013-04-12T14:22:16Z

Three years of Vaadin Directory

Vaadin Directory has turned 3 years of age already. The Vaadin Framework itself features a lot of widgets and components, but it cannot have all the features in the world without becoming too big and unusable. The goal of the Vaadin Directory was to “make creation, finding, evaluation, integration and buying Vaadin Add-ons easy”. And now, varying from UI widgets to data binding helpers and development tools, Vaadin Directory hosts nearly 350 add-ons to the framework. If you think about this number, it means that the Directory has seen a new add-on every three days - that’s amazing!

Here are some statistics:

Total add-ons to date: 348
Open-source add-ons: 336
Official Vaadin add-ons: 19
Most versions for a single add-on: 35 (CKEditor)
Add-on authors: 144 
Most add-ons per author: 18 (by Matti Tahvonen)
Total downloads to date: 460 025
Vaadin 7 compatible add-ons: 143

Of course most developers just use the add-ons, but there is a good number of add-on authors too. This goes to indicate how the community works, from developers to developers. Also, as you can see from the numbers above, along with our official Vaadin add-ons, most of the stuff is free and open source.

Make it better and win

We have seen a couple of competitions and prizes for add-on authors during the history of the Directory. And we like to keep it that way in the future too. This time we are asking you to participate in a very brief survey.

To keep Vaadin Directory relevant to everyone, we are asking you to tell how do you use Vaadin add-ons in your development. Please take a minute to answer the survey and you can win Vaadin related prizes by leaving your contact email.

Here is the link to the survey.

That should be quick enough to fill during the GWT compilation, and if you have any suggestions, this is your spot. Thanks in advance!

Accessibility with WAI-ARIA

2013-04-02T09:32:35Z

I recently had the opportunity to work on WAI-ARIA additions to the Vaadin core framework. WAI-ARIA is short for Web Accessibility Initiative - Accessible Rich Internet Applications Suite. Through this, it is possible to make web application like the one's created with Vaadin accessible for assistive devices like screen readers.

Having had the pleasure to study at a campus together with students with disabilities, I know very well how hard life can be without eyesight or the ability to walk. This is why I'm feeling very proud for being able to work on reducing this pain at least a bit in the context of Vaadin. For me, every user wins when some thoughts are spent for accessibility, as the usability for everyone will increase.

And it is often the simple things that make work unnecessarily difficult. One great example we had today in the office, were an Eclipse plug-in marked an area in the window sidebar red, to indicate a certain area in source code. Well, when the person in front of the computer is colour blind for red, this doesn't help at all (yes, there is a Vaadin add-on to learn about such situations in your Vaadin applications).

Obviously, the framework can't make your application accessible on it's own, but it should make it easy for you to get there. And this is what we are targeting. We also understand that accessibility is an ongoing process, and we are just at the beginning. We also would be very interested to learn about the requirements you have regarding accessibility for your applications.

Very short intro

As I was working on support for JAWS (currently the most widely used screen reader), the content of this post is somewhat specific to using a Vaadin application with this screen reader. Alternatives to this application exist. More about this later.

Now, the task here is to help the screen reader to understand the content of an HTML page. This is easier with static HTML, where mostly regular elements are used, as these are directly recognized. For example, when the following is used for a button, this will be automatically recognized:

<button name="button">Click me</button>

Things get tricky when a button suddenly looks like this:

    <div tabindex="0" class="v-button">
      <span class="v-button-wrap">
        <img alt="" class="v-icon" src="http://vaadin.com/path/action_save.gif">
        <span class="v-button-caption">Save</span>
      </span>
    </div>

So in such cases, the screen reader needs some help. For this, WAI-ARIA specifies additional attributes that can be added to the important elements. The first step for the button above would be, to add a role to the root element. This will define the whole element as a button:

<div role="button" tabindex="0"...

To make it clear where the label of the button is hidden, it is possible to add an attribute aria-labelledby

<div role="button" aria-labelledby="uniquelabelid"  tabindex="0"...

Then the label needs an id

<span id="uniquelabelid" class="v-button-caption">Save</span>

The next information that is important to know is, if the button is pressed or not

<div role="button" aria-pressed="false" aria-labelledby="uniquelabelid" tabindex="0" ...

Now, we have specified what kind of widget we are dealing with, where to find important information related to it and defined its state. Of course this is only a very simple example, but I hope you get the idea. You can find some links to introductions at the bottom of this post.

One thing that is also very important for the browser is, when, based on a user interaction in one part of the page, content in a different area of the page changes. These need to be specified as so called live regions. An example would be a notification. This is of course very important for the user to know, but the screen reader would not be aware of it on its own.

Helper

As I always wrote about GWT functions on this blog so far, I bet you already guessed it - yes GWT offers an easy way to handle the WAI-ARIA attributes. The class com.google.gwt.aria.client.Roles provides a lot of static functions, to help you set the correct attribute for the specific element. Setting the button role looks like this:

Roles.getButtonRole().set(buttonElement);

Specifying the label element:

Roles.getButtonRole().setAriaLabelledbyProperty(buttonelement, Id.of(labelelement));

And finally to define the state

Roles.getButtonRole().setAriaPressedState(buttonelement, PressedValue.TRUE);

Now you may be thinking, "well, this should the Vaadin framework do automatically". Correct, this is exactly what I was working on and will hopefully soon be available in the repository for the button, form fields and the tree.

But there are things the framework can't decide for you. For example, every image that is not there for pure visual reasons need an alt text, which the screen reader can read out loud so the image can be understood when it can't be seen. This needs to be set by the application developer (and the framework needs to offer the respective calls).

And when writing your own Components and add-ons, please don't forget about accessibility.

Of course the widgets are only part of the story. Structuring your content is at least equally important. Screen readers extract all the headings, links, landmarks and the likes from the page, and makes it easy for the user to get to know the content of the page and jump directly to it.

There is a lot of information on the web about accessibility. Sites I check regularly is WebAIM, which offers information about any subject around accessability. Very practical information can be found in the blog of Marko Zehe. When you are in Germany and have a chance to attend a conference talk from him, this is a must do! You can find more resources at the end of this post.

How to test

Now the tricky part - testing. Of course, the best way is to switch off the screen, fire up an assistive device and try to use your application. Most of the things that are not optimal yet will become very clear to you pretty fast. Working that way through your application together with the best practices specification from W3C will help you a lot to understand what is needed to make your application accessible.

JAWS is a commercial product, that is available in an evaluation form, that can be used for 40 minutes. When you want to continue to use it, you need to restart the computer. I read somewhere, that its license does not allow developers to use this version for testing, so you can use it only for evaluation. We contacted them because we saw JAWS doing things not correctly, to understand where the problem comes from. They outright answered to us, they don't provide support. Good thing, NVDA did most of the things correctly.

NVDA is one of the many free alternatives, that was mentioned to me a lot. It is not so widely used as JAWS, but it is increasing. And there are specific plug-ins for Firefox and Chrome.

But, there is a catch: Screen readers bring a whole new level of browser dependant behaviour. What the screen reader reads out varies not only between screen readers, but also based on the browser (and version) it is used with. So maybe it is a good idea to choose a screen reader / browser combination when you are starting to make your application accessible. Once again, choosing Firefox over Internet Explorer showed better results.

Yes it is hard to get started, and it is even harder to get it right, but it is an important thing to do, to allow everybody to take advantage of your application. Having the possibility to let your application checked by a regular user of assistive devices is enormously helpful.

I would be very interested to hear from you what specific requirements you have regarding accessibility that the framework should provide for you. Especially feedback about my changes are very welcome. The first batch should soon be in the repository, and hopefully soon in a beta near you.

Let's work together on this. It will take its time, but I am sure we will get there.

Resources

Michael works at the Vaadin team as GWT expert helping our customers in building custom widgets and solutions on top of Vaadin Framework and GWT.

Agility and ISO 9001

2013-03-28T06:26:07Z

If you are well informed about your own organization and your surroundings, it’s easier to serve customers and make good decisions. This was known already to Sun Tzu and is also one cornerstone of the ISO 9001 standard. ISO 9001 is a quality standard focusing on the very basics of the organization, like clear responsibilities or customer satisfaction. For example, the standard thinks that it’s good to know who is responsible and for what, and it’s good to know how satisfied the customers are.

You probably have guessed already that Vaadin has just received its ISO certificate. The reason why Vaadin decided to develop a quality system was surprisingly agility: if things are clear and there is plenty of data to support our actions, we can keep our promises easier and make fast and well informed decisions. For Vaadin quality means that people, communication, collaboration and responsiveness are emphasized, while all unnecessary documentation and processes are left out. Just like in the Agile Manifesto.

Vaadin’s mission is to make building amazing web applications easy. Two important aspects of this mission are to arrange good training courses and deliver successful projects to the customers. Therefore it’s important for us to know what our customers think about our services. We started measuring the customer satisfaction roughly one year ago, and currently our past three month customer satisfaction is 4.24 / 5.00 for training courses and 4.39 / 5.00 for project deliveries. It’s easy to be proud of these scores! Although we try to improve constantly.

Other examples are Vaadin Framework itself and our add-on components. In addition to measuring the customer satisfaction, we’re also collecting customer feedback and experiences by using several different information sources. This information is used for building product roadmaps and release plans. Community’s opinion weights a lot!

By this point you’ve probably got the idea of the ISO 9001 standard. It’s about doing the basic things better. While Vaadin emphasizes innovation, creativity and aesthetics a lot, we also believe that these aspects benefit from having the basic things right.

We hope that you can notice both the precision and creativity always when you encounter Vaadin.

Vaadin 7 edition of Book of Vaadin

2013-03-20T16:33:13Z

I am happy to announce that the new Vaadin 7 edition of the book just came out of print. The book is thicker than ever, perfect for bashing others over technical Vaadin details, and the color of the cover is this time...drumroll...red. We will again be giving away copies for free at events which we attend to, so please come meet us and get yours.

Marko Grönroos is a technical writer working at Vaadin, and the author of Book of Vaadin.

The web edition, as well as the PDF and ePub editions, are of course always there for you with the most up-to-date content. Most of the book examples are available live.

So, what’s new in the book? Since the Vaadin 6 edition, the introductory Part I and the Chapter 4 on server-side application development have been completely revised to talk about UIs, Pages, VaadinServlets, VaadinSessions, and so forth. A part of the installation chapter has changed, mostly because of the adoption of Ivy in Eclipse projects. There is a new section about basics of application architectures with Vaadin. Note also the new section about navigation using the new Navigator in the advanced topics chapter, although that will probably be moved to the Chapter 4 in the next edition, as it is such a basic topic after all.

With basic components, few have changed significantly. The Embedded component was split into Image, Flash, and BrowserFrame, and CustomField was included. The deprecated Form is no longer included in the book, but there is a new section about using the FieldGroup to create forms. Note also the use of property converters in Vaadin 7. An intro about Sass themes is now included. Popup windows, embedding, request handlers, printing, JavaScript API, and so on and so on.

One of the biggest changes in Vaadin 7 was the complete overhaul of the client-server communication and the API, which now uses shared states, RPC, and connectors, so we now have an entirely new Part III about client-side development, where the integration chapter has been completely rewritten. The part also includes more general information about GWT development, as GWT is included in Vaadin 7. The support for client-side development has been evolving quickly and the part will receive plenty of further revision in the future.

The Part IV about add-ons has received a new chapter about the Vaadin Charts, which is our new high-end charting component based on HighCharts. The Vaadin Timeline is now included in Charts, although still documented in a separate chapter. Also the chapter on TouchKit was revised for the new Vaadin 7 style API in TouchKit.

As often is the case, Vaadin has developed much too fast to keep the book completely up-to-date with it. Some important chapters and sections will be updated more thoroughly later.

One interesting topic in the future is the translation of the book into different languages. Vaadin has large user communities in many non-English-speaking countries. We had an experimental translation project of Book of Vaadin 6. We got especially many Spanish translations of the first chapters of the book, as well as many Czech and French. We will, at some point, look how to transition the project to the Vaadin 7 book.

You can pick up a free copy of the book at Devoxx UK, Devoxx FRA, Vaadin Meetups, and at some other events in Spring 2013. Please see our event calendar.

Sampler rethought

2013-03-15T11:52:57Z

Frameworks are pretty hard to demo - they are just a pile of API that does not look much. It would take quite a while too long to see the beauty of the framework just by looking at the API. In case of UI frameworks, there is also a bunch of UI components, but even they are fairly hard to demo properly.

We first faced this problem in year 2002 when we open-sourced Vaadin (which was called Millstone 3 back then). The solution we came up with was called Feature Browser - a little application literally designed for browsing though the features our framework had.

Predecessor of Sampler from year 2002

Feature Browser immediately became a hit - something that defined how people perceived our framework. It was used for taking the first look into the framework, demoing the framework to others and learning how the features of the framework worked. Later on we started calling this application Sampler - to emphasize that it contains samples of the framework features you can play with.

With Vaadin 7 we decided to re-invent the Sampler. We wanted to find a fresh way of demonstrating the features of the framework, to give you more control over the demonstrated features and to go from demoing just the visual UI components to also revealing what is under the cover. We also built the infrastructure for demoing add-on components inside the Sampler - to be able to show that there are quite a few more features in Vaadin than what is included in the product core.

Built for demos

First of all - we want to get you to say WOW - regardless of whether you try Sampler by yourself or see someone else demoing it. We hope we succeed when you first try it out. After the magic of the animated transitions wears off, you probably start using the built in search functionality more than fly through the menus.

Flying through the samples gives you a taste of what Vaadin can do.

Everything in Sampler takes the center stage. At first it may seem minimalistic to put just one button in the middle of the screen under a spotlight. We want to give you an opportunity to put the features of Vaadin under your undivided focus one by one and to let you torture test them and see if all of the pixels are right. Details matter - these are the building blocks of your application.

Your guide to Vaadin

Sampler is not just a demo. It can also be a learning tool. For this every sample includes a description teaching you about the feature and includes pointers to Book of Vaadin and API. To experiment with the UI components, you can open up the properties dialog and modify the components on the fly and resize the area where the components reside. This should be much faster than trying out the properties in your own application.

You can modify the properties of the UI components to see how they behave.

One of the most powerful features is that the samples include source code - right inside Sampler. In fact, the source is in many cases half of the sample - it gives you an opportunity to study how to accomplish what you see on the screen.

Before you dive into the new Sampler, please remember that this is just the beginning of the new generation. We look forward to adding many new features and add-ons to Sampler later on. And while you are looking at the Sampler, please do us a favor and report the bugs you bump into.

Experience the new Vaadin Sampler!

Introducing Community Cloud

2013-03-12T13:41:42Z

We're excited to finally reveal something we've had under the covers for a while now. We're confident that this will be something that you, the community, will appreciate too.

We've partnered up with Jelastic and ServInt, to provide you with a little slice of the web: Community Cloud. Community Cloud provides every vaadin.com member with non-expiring accounts for Jelastic, running on top of ServInt's servers. These accounts are intended and designed as a place where you can put your Vaadin demo applications you make.

Jelastic provides each registered vaadin.com user a free, non-expiring account with a customizable server that you can control entirely with your web browser with ease. No need for SSH, FTP or any other abbreviations, nor do you need to know Linux at all. You just upload your WAR-file, deploy it to your server, and you're done.

All this is provided for you, by Jelastic, ServInt and Vaadin, for no cost. Just make sure you're logged in to vaadin.com, go to vaadin.com/cloud and enter your email. You're one button press away from having an awesome place to drop your Vaadin demos into.

Vaadin Development Team Update 03/2013

2013-03-08T13:30:04Z

It has mostly been business as usual since the last update - lots of small things worth mentioning but nothing as spectacular as the release of Vaadin 7.0.0 last month. Maybe the biggest of the small things is the first maintenance release for Vaadin 7, including a whopping 51 fixes and small enhancements, compared to the 10 - 15 fixes typically included in our maintenance releases. The majority of the fixes have been related to the Sass compiler, layouts and client-side performance. The performance fixes also includes a new profiler that lets you investigate the performance of the framework as well as your own client-side code. More optimizations and assorted bug fixes are included in 7.0.2, which will be released later today. We have also released Vaadin 6.8.9 with some fixes.

Work on new features for Vaadin 7.1 has also begun with promising progress integrating Atmosphere Framework into Vaadin for full-featured server push support for modern browsers and transparent fallbacks for the rest of the pack. A functional proof of concept was made in less than a week, after which focus has shifted towards extending the core API to enable plugging in any communication method and providing the Atmosphere integration as the default implementation. One new feature that has already landed in the master branch (from which 7.1 will be branched before the release) is basic support for arithmetics in the Sass compiler. You can already try out a nightly build, or wait until the end of March for a beta release. One final highlight for Vaadin 7.1 is that we have made it easier set up a development environment for making your own contributions to the project.

Independent of the core framework roadmap, we are also making updates to our CDI integration, aiming for an official alpha release towards the end of the month. With all these things going on, there is unfortunately not much time left for prototyping high risk features that we might want to include in Vaadin 7.2 or subsequent minor releases. Rest assured that we will be drawn back to inventing the future once we are satisfied with the new stuff going into 7.1.

Vaadin Charts export from browser to SVG and PDF

2013-02-28T14:57:29Z

Blog post by Matti Tahvonen:

Like most new chart libraries of our era, Vaadin Charts was born for the web. Behind the scenes, we rely on the industry leading Highcharts JS library, which renders charts in the browser using the standard SVG vector format. Even though SVG had a rocky start, modern browsers nowadays offer great support for the format. IE8 is the last pain in the butt, but luckily Highcharts does a great job rendering charts in Microsoft’s proprietary VML format as well.

The real value of Vaadin Charts comes from its clean Java API. Using the API, it builds a compact JSON representation of a chart, which is then passed to the browser and Highcharts for rendering. Due to the Java API, the integrated documentation, and a modern IDE, all Java developers will feel comfortable with Vaadin Charts from the very beginning.

Basic usage of the API is so simple that I see no point in boring you with usage examples. Download Vaadin Charts, check out the examples and play with it in your favourite IDE. That’s the best way to get convinced!

Instead of basic examples, I want to answer one of the most common questions from evaluators: "Can I use the same chart in a PDF file I need to generate due to accounting legislation?" As you might guess, the answer is yes. And it has got nothing to do with those naive "print" and "download as" buttons you have spotted elsewhere.

Although the actual rendering of charts happens on the client side using browser technologies, there are tools that let us generate the very same SVG completely on the server side. PhantomJS is a lightweight headless browser, based on the WebKit rendering engine. It is most commonly used for testing purposes. Once you have installed PhantomJS, you can use a helper class in Vaadin Charts to generate an SVG representation of your chart. After that, there is no limit to the possibilities of creative Java developers.

You can generate an SVG from the same Configuration object that you use in your browser UI like this:

	String svg = SVGGenerator.getInstance().generate(configuration);

The helper class automatically starts a PhantomJS process that it uses to render charts into SVG format. The first pass takes about a second, but subsequent requests take just around 20ms on my development machine.

Once you have the chart in SVG format, you can do pretty much anything you want with it. If the raw SVG format is not suitable for your needs, Batik is a great Java library to hook it up to your processes.

To demonstrate the feature, we have prepared a simple example project that you can check out from our SVN repository and play with. It displays a chart in a Vaadin UI, which can then be exported into various formats. The server side generated SVG can be downloaded as such or as a part of a PDF report generated with the iText library. To emphasize the agility of Vaadin Charts, there is also an example that opens a Swing UI (JPanel) displaying the SVG on the server. Now you can start porting your legacy Swing app to Vaadin starting with the charts :-)

Related Links:
The example project that uses an exported chart in a Swing app, as a downloadable SVG, and embedded in a PDF.
PhantomJS - The tool that needs to be installed for server side usage.
Batik Toolkit - A general purpose SVG library for Java.

Matti Tahvonen works at the Vaadin team building products like the Vaadin Charts. If you want to meet Matti and ask more about Vaadin Charts join us for a webinar on March 12.

Extending components in Vaadin 7

2013-02-26T18:53:18Z

The ability to extend components is one of the great new features of Vaadin 7. By using extensions you don't have to reinvent the wheel—you can adjust the outlook or the behavior of the existing components instead of creating new ones, thus minimizing the need for copy-paste code.

I have been working at Vaadin for a bit over a year, and in about every project that I have worked on, there has been a need for one simple feature: a reset button on a text field. Take a look, for example, at your favorite touch-device or Spotify and you see it in action. When you type something in a text field, an X button appears. And when you click or tap the button the text is gone! So easy—no need to use delete or backspace ever again.

A resettable text field in action

Thus far, I have implemented it separately project-by-project. Copy-paste, boilerplate, stupidity? Call it whatever you want, but every time I have done this, I haven't been able to stop myself from wondering: could this be a place for an add-on?

From ResettableTextField to ResetButtonForTextField

In Vaadin 6, I would probably have created a CustomComponent containing a layout that would have a TextField and a Button. In order to make the component usable, I would probably have used CustomField add-on. There we would have it: another text field component, ResettableTextField.

But then Vaadin 7 was released with an API for creating extensions for components. Excitement was in the air: there was no need to recreate the TextField anymore; I was just able to extend the existing one. Since I was now creating an extension instead of a component, the project needed a new name: ResetButtonForTextField.

Let's keep it simple

So the idea is to create an extension for the TextField class that adds a button that resets the field? As expected, the server-side is the easy part because it has only one responsibility: to grab the TextField component to be extended.

public class ResetButtonForTextField extends AbstractExtension {
    public static void extend(TextField field) {
        new ResetButtonForTextField().extend((AbstractClientConnector) field);
    }
}

Client-side: a text field, a button, and some listeners

The client-side is responsible for creating the reset button and changing its visibility. It needs to listen to the changes in the text field so that the button is shown and hidden appropriately. Naturally it also handles the clicks of the button itself.

Our client-side class is ResetButtonForTextFieldConnector that extends AbstractExtensionConnector. It is connected to the server-side by using the @Connect annotation.

As the first thing, we add a state change handler to the ServerConnector object given as a parameter so that we can notify the client-side if the value of the text field is changed from the server-side. Since there's no guarantee that our state change handler is always invoked after the TextFieldConnector has added the new value to the DOM, the actual checking is deferred to ensure that we always get the latest value.

target.addStateChangeHandler(new StateChangeEvent.StateChangeHandler() {
    @Override
    public void onStateChanged(StateChangeEvent stateChangeEvent) {
        Scheduler.get().scheduleDeferred(new ScheduledCommand() {
            @Override
            public void execute() {
                updateResetButtonVisibility();
            }
        });
    }
});

Then the VTextField object is retrieved from the connector and a style name is applied to it so that we can apply our own custom styles to it. After that, we create the actual reset button. A VButton could be used here, but because the parent of the text field can most likely hold only one widget, trying to insert another one next to the field would be hard, if not impossible. Instead, we only create a DIV element and apply a style name to it too.

textField = (VTextField) ((ComponentConnector) target).getWidget();
textField.addStyleName(CLASSNAME + "-textfield");

resetButtonElement = DOM.createDiv();
resetButtonElement.addClassName(CLASSNAME + "-resetbutton");

Notice that the updateResetButtonVisibility() function used in these snippets is a helper function that shows or hides the button based on whether the value of the text field is empty or not.

private void updateResetButtonVisibility() {
    if (textField.getValue().isEmpty()) {
        resetButtonElement.getStyle().setDisplay(Display.NONE);
    } else {
        resetButtonElement.getStyle().clearDisplay();
    }
}

The reset button element is inserted next to the field during the attach event of the text field and removed during the detach. This is to make sure that it is always there when the text field is appended to the DOM.

public void onAttachOrDetach(AttachEvent event) {
    if (event.isAttached()) {
        textField.getElement().getParentElement()
                .insertAfter(resetButtonElement, textField.getElement());
        updateResetButtonVisibility();
        addResetButtonClickListener(resetButtonElement);
    } else {
        Element parentElement = resetButtonElement.getParentElement();
        if (parentElement != null) {
            parentElement.removeChild(resetButtonElement);
        }
        removeResetButtonClickListener(resetButtonElement);
    }
}

For the same reason, the click listener for the reset button is also added and removed during attach and detach. Since in GWT it is not possible to add event listeners directly to element objects, we'll need to use pure JavaScript by using JavaScript Native Interface. In case you want to know more about JSNI, I recommend reading a blog post by our GWT Expert, Michael Vogt.

The function addResetButtonClickHandler() simply applies an onclick listener to the reset button element.

public native void addResetButtonClickListener(Element el)
/*-{
    var self = this; 
    el.onclick = $entry(function() { 
        self.@org.vaadin.resetbuttonfortextfield.widgetset.client.ResetButtonForTextFieldConnector::clearTextField()();
    }); 
}-*/;

All it does is a call to clearTextField() function that sets the value of the text field to an empty string, notifies the server about the new value and then hides the reset button. Finally, it focuses the text field. This is a usability thing: if the user resets the field, she wants to write something in it, right?

private void clearTextField() {
    textField.setValue("");
    textField.valueChange(true);
    updateResetButtonVisibility();
    textField.getElement().focus();
}

The removeResetButtonClickListener() function is as simple as it gets. It just sets the onclick listener to null so that unused event listeners are not left lingering when the component is detached.

public native void removeResetButtonClickListener(Element el)
/*-{
    el.onclick = null
}-*/;

One more event handler is required. It is a key up handler that is activated when the user types something in the field, showing and hiding the reset button whether the field is empty or not.

public void onKeyUp(KeyUpEvent event) {
    updateResetButtonVisibility();
}

There we have it: a nice text field with a miraculously appearing reset button! You can view the full code for the ResetButtonForTextFieldConnector class in GitHub.

One final thing: styling

Without any styles our reset button is just an empty DIV. Since we want to position the button over the text field, some padding is added to the right side of the field. Then the reset button is sized, positioned and visualized.

From the outlook of the reset button I wanted two things: it had to look constant in every browser and it had to scale nicely. Therefore, I decided to use SVG images. I also made PNG renders of them so that IE8 users would get nice round images too. The latest version of the CSS file can be found from GitHub.

In my style names, I have used resetbuttonfortextfield instead of the v prefix used in the Vaadin core components. There are simple reasons for that, covered in a blog post by Vaadin Expert Marc Englund. To summarize, the styles prefixed with v are intended for the Vaadin core only. This is to make sure that no collisions between styles are caused; neither mine nor the core styles should affect each other unintentionally.

In order to load the stylesheet file as a part of the widgetset, I added the line <stylesteet src="resetbuttonfortextfield/styles.css" /> in the ResetButtonForTextFieldWidgetset.gwt.xml file. Now the widgetset compiler knows to look for the file from the path public/resetbuttonfortextfield located under the directory of the xml file.

The final structure of the project

How is it used?

The usage of this extension is really simple. Just add its JAR to you project, compile the widgetset and then extend any TextField component.

TextField tf = new TextField();
ResetButtonForTextField.extend(tf);

That's it. Really. Now your text field has a reset button.

The four phases of a TextField extended with a ResetButtonForTextField

Final words and links

As you probably can imagine, everybody here in the office has been talking endlessly about how Vaadin 7 changes everything, offering great new possibilities to the developers. At least in this context, it means that instead of a need for hacky approaches, the framework offers you the possibility to modify the way things work. Directly.

I hope that you find ResetButtonForTextField as a good example on how to make extensions for components. I tried to make an example that would be as simple as possible while still creating an extension that has a real purpose.

As final words, I want to thank Johannes Dahlström and John Ahlroos for writing these fine Wiki articles: Creating an UI extension and Creating a Component extension.

The complete source code for this project is available in GitHub. You can also check out the demo application. As always, the easiest way to use the extension in your project is to grab it from the Vaadin Directory.

Tapio works at the Vaadin team helping our customers in building solutions on top of Vaadin Framework. His main responsibility is to solve the support requests made by our pro account customers. Ask us anything and we'll answer it.

Vaadin Charts 1.0 - ready for reporting UIs

2013-02-21T13:39:03Z

Great news for all Pro Account users! Vaadin Charts has reached the 1.0 and is now available for download from the Directory.

Pie, bar, scatter, stacked, timeline, ...

Vaadin Charts has all the features you need to build cool reporting user interfaces to your application. You have seen this in the Quicktickets Dashboard, the Vaadin 7 demo application, but you can find samples of virtually all charts you can imagine in the Charts demo application - with the source code, of course.

Good looking and interactive charts are the primary thing. In addition to these we have a good set of important features:

High quality vector printing (SVG)
Reusing charts on the server-side, for example in PDF reports
Adding your own custom chart types

We will cover some of these features in the upcoming technical blog posts and developer webinar.

Trying it out now

If you like to test and use Vaadin Charts right now, just log in to vaadin.com and go to vaadin.com/charts, click the download link and either download the zip file or follow the Maven instructions. You can try it out for 30 days for free and purchase later either with Pro Account or a separate license.

You can find the full documentation in the Book of Vaadin, but using the charts in your application is as easy as using any Vaadin add-on component. After installing the jar, all you need to do is write the Java code. Here is a small sample of plotting the memory usage of the server the app is running on.

// Create a chart configuration
Configuration conf = new Configuration();
conf.setTitle("Server Memory Use");

// Configure Y axis
YAxis memAxis = new YAxis();
memAxis.setTitle("Memory use (in bytes)");
conf.addyAxis(memAxis);

// Configure and add chart to a layout
Chart chart = new Chart();
chart.setConfiguration(conf);
layout.addComponent(chart);

// Initialize data series for content
DataSeries mem = new DataSeries();
mem.setPlotOptions(new PlotOptionsSpline());
mem.setyAxis(0);
conf.addSeries(mem);

// Add a data point (long values will do)
Runtime r = Runtime.getRuntime();
mem.add(new DataSeriesItem(System.currentTimeMillis(), r.totalMemory()
		- r.freeMemory()));

// Todo: Start a thread to repeat and update the data.

If you want take a look at the full working sample of real time spline charting you can find it here.

Join us for a Vaadin Charts developer webinar!

To help you learn more about Vaadin Charts, we invite you to join us for a special developer webinar on Tuesday March 12. We want to give you a demo and some getting started pointers as well as hear what you might have in mind. So, if you have any questions about Vaadin Charts, the guys behind the product, Sami Kaksonen and Matti Tahvonen are there to chat with you. The webinar is free for everyone, so enroll now!

Roadmap for the next 74 days

2013-02-15T16:20:41Z

Vaadin 7 is done, now what?

One of the lessons learned from our Vaadin 7 mega-project was that we should be taking smaller steps in future. Furthermore, we should not tie uncertain features to product releases before they are properly researched and prototyped. So we are not going to announce what we’ll be doing for the next 16 months. We’ll be also spinning off quite a few research projects outside the roadmap to prepare for the next big thing.

Here is what we are planning to release before May. It is a rather long list, so now would be good time to fetch a cup of coffee...

Vaadin Framework 7.1 brings push

7.1 will be all about server-push. We’ll be supporting both HTML5 web sockets, long polling as well as - well - just polling. Because the framework takes care of the client-server communications, this is going to be huge - everything you have already implemented with Vaadin will be push enabled automatically. For a taste of this, you can take a look at the best push add-on for Vaadin 6.

We are also planning for a quite a smaller features for 7.1:

Vaadin Calendar will be merged into the framework as it is now fully free
Native mode support for Internet Explorer 10 (7.0 runs IE10 in IE9 compatibility mode)
Allow injecting styles dynamically from Java code (like this add-on)
The Debug donsole will be redesigned with new features like:
- Generate an optimal widget set for your application to effectively to allow radically cutting down the size of initially loaded JavaScript to speed up application startup
- Generate independent implementation of the visible view. This allows you to easily build a test-case or get designers onboard to build a custom theme for your app without requiring them to set up the development enviornment for your application.
Arithmetics support in the Sass compiler
A mechanism for packaging CSS in add-ons without a widgetset

In addition to 7.1 are busy working on 7.0.x maintenance releases and are planning to release them frequently - once per every 2-3 weeks. The 7.0.1 version will be released next week and introduces significant rendering performance optimizations.

While the roadmap after 7.1 is not set yet, we will be researching quite a few interesting topics for inclusion in 7.x releases - including a client-side data model, a new Table and Combobox design, responsive layouts and a new theme. Nothing to report yet on these, but stay tuned.

Vaadin JPAContainer wants to be free and redesigned

JPAContainer has been around since 2010 allowing one easily use JPA as a datasource in Vaadin UI components. While it is a very powerful tool, it has also received critique for two things: 1) connecting the UI component directly to JPA leaves little space for business logic between these layers if the business logic is not implemented in the entity beans and 2) JPA support is such an integral part of the application core that a non-free license has not been an option for some. We have heard the message loud and clear and will be addressing both of the concerns.

Vaadin JPAContainer will be moved to Apache 2.0 license. Vaadin 7 support will be added in the next version 3.0 of the Vaadin JPAContainer. A beta version will be published on Feb 28th and the final 3.0 version in March. We will also publish a Vaadin 6 compatbile free version of the add-on, 2.2 by the end of February.

The limitations of the current version (and 3.0) of the add-on are that while it works well in apps with domain oriented architecture its usability is limited in SOA architectures because it bypasses the service layer. Furthermore, the transaction support is somewhat limited. Keep these in mind when you use the add-on and it can help you simplify your JPA use a lot.

For the next generation of the JPAContainer it’s architecture will be re-designed to split it to a generic lazy loading container that can handle multiple backends and contain custom logic between the Container API and the backend. Work on this design will most likely start before summer. If you want to use a JPA agnostic lazy loading container today, there is an add-on for that. Instead of planning to release a “4.0” of the JPAContainer as an add-on, we’ll most probably include the functionality directly in the Vaadin Framework in the future.

Vaadin Charts to be released next week

If you have not taken a look at our hot new visualization library already, now would be a good time. The 1.0 final version will be released next week.

Even before 1.0 is out, we are already planning the next version. Vaadin Charts 1.1 will be released in April with many new charts and features:

Funnel series
Box plot series
Waterfall series
Bubble series
Error bars
Color thresholds for different coloring of a graph above and below a threshold
Pinch zooming and panning for touch devices
Autosizing pie charts to make room for labels

Vaadin TouchKit 3.0 adds Vaadin 7 support in March

While alpha level support for Vaadin 7 was released in the beginning of the year already, there is still work to do - mostly related to optimizing performance. While the 3.0 release is mostly about Vaadin 7 support, it will also introduce a couple of new components:

URLField
Datefield
Combobox

3.0 beta is planned by the end of February.

Being from the land of Nokia, we are looking for possibilities to introduce support for Windows Phones. At the moment there are two challenges we are going to work ok: adding IE10 support for Vaadin 7 and GWT as well as creating a Pointer Events API for GWT. We hope to be able to contribute this work to GWT 2.6 later on.

Book of Vaadin 7

A major API renewal of Vaadin 7 meant also a major update to Book of Vaadin. To make the challenge even larger, the API was still changing quite a bit during the beta phase and documenting a moving target was practically impossible. The deadline for the “Book of Vaadin 7” is the end of Feb, but you can read the nightly version online already.

After the book is done, we would love to see the community driven translations project going as well. Wouldn’t it be wonderful to have Book of Vaadin 7 other languages also?

Official CDI support

Adam Bien and Peter Lehto have been preparing a CDI integration for Vaadin for a while. The integration makes use of Java EE 6 CDI very natural because there are Vaadin specific contexts and one can add UIs and Views to your application just by annotating them. There are also helper utils for using JAAS in your project.

The work is available under Apache 2.0 license today. The integration looks so promising that it will be promoted to an officially supported add-on shortly. 1.0 beta is planned for March and 1.0 final a month after that.

Spring Clean-up

The roadmap is not just about adding things - we are also planning to remove some things.

Plug-in for Spring Roo is discontinued

We had great expectations for the Roo plug-in, but unfortunately it did not take off as well as we would have liked to. Thus we made a hard decision not to continue development of the Roo plug-in or to port it to Vaadin 7.

The idea is still valid and with the Apache 2.0 licensed JPAContainer this plugin could be even more powerful than before. If anyone is interested in continuing the work on the Roo plugin, we would be happy to hand it over and help promoting this work.

WSRP Add-on will not be ported to Vaadin 7

Use of Web Services for Remote Portlets (WSRP) has been quite rare with Vaadin. While the current WSRP add-on is fully functional, it has been left beta and will not be ported to Vaadin 7. With the new extension points in Vaadin 7, maintaining WSRP support could be done in your application if you really really need this. If you do, feel free to publish your support as an add-on.

XS Add-on functionality to be added to Vaadin Framework?

Being able to embed any Vaadin app in any web page is quite a value proposition. This is so useful that we’ll be researching ways to include this directly in Vaadin Framework and to discontinue this separate add-on. So do not expect release of a 1.0 version of it.

We would like to kill "Vaadin Bundle for Eclipse"

Frankly, we would like to kill this separately packaged Framework+Eclipse Plug-in bundle. The only purpose of the add-on has been to allow use of Vaadin for people who work behind strangely configured enterprise firewalls that block connections from Eclipse.

If you really really need this add-on, please comment below and explain why.

Merging products

Quite a few official add-on products are merged to other products:

Timeline will be merged into Vaadin Charts 1.0
Calendar will be merged into Vaadin Framework 7.1
ColorPicker was merged into Vaadin Framework 7.0
Bean Validation was merged into Vaadin Framework 7.0

Vaadin 6 compatible versions of these products are maintained, but further development is done within the products they are merged into.

That's (most of) it - for the next 74 days. There are some other things I would love to tell you about as well, but that would spoil the surprise :)

Vaadin Calendar is now free for everyone

2013-02-14T22:02:25Z

Good news for all Java and open source enthusiasts! We have decided to open source the Vaadin Calendar add-on for everyone. Previously dual-licensed either under AGPL open source license or CVAL commercial license it is today available under more liberal Apache 2.0 license. The Vaadin Calendar will continue to be a first-class Vaadin component and we will continue to keep it the best calendar widget of them of all.

Vaadin 7 support is here

For those who haven’t seen the component earlier, the Vaadin Calendar is a component for Vaadin to display and edit weekly and monthly calendar views. The calendar includes many nice features like drag and drop editing of events as well as locale and timezone support. Previously available as an add-on for Vaadin 6 the version 2.0 of the add-on supports Vaadin 7.

The top conference calendar

During the last couple of years the Vaadin Calendar has been widely seen in different Java conferences as their schedule browser. That is originally because the Devoxx schedule built for 2010 edition of the European conference. This application uses the Vaadin Calendar to display the schedule for the conference. Since then the application has been themed to match the Devoxx and Jfokus conference website styles. If you like to take a look how to style the Vaadin Calendar, the schedule application is open source and available at Google Code.

We hope the license change is encouraging people to create more similar success.

PS. We will discuss about the Vaadin roadmap more in a separate blog post soon.