2016 Recap

That’s it folks. We are ready to move this year into the “Done” column. I guess we are all eager to jump ahead to 2017 already, but let’s take the traditional retrospective of 2016 before doing that.

As a company we have continued the steady growth. Our internal chat channel now lists 137 members. This means some 30% growth since last year. In addition there are now over 1k Certified Vaadin Developers around the world. 

A bigger Vaadin team means that we can do more for you. This year, we published 100 articles in the blog, attended over 20 events and had almost 40 speeches in conferences and user groups - including our own Vaadin Dev Days. I guess many of you have participated in some of our tech webinars, but the thing that we really have put more focus on this year are our tutorial videos.  Vaadin YouTube channel is becoming the most popular resource for learning new stuff, with over 1.3 million views this year.


With product releases we did extremely well. Vaadin Core Elements got 6 releases, the framework a full 21 releases and the next major version, Vaadin Framework 8, is already in beta. With renewed simple, Java 8 compatible data APIs, we are expecting a lot from it.

But that is not all that has happened. You in the community seriously overshadowed official release statistics with a total of 107 new add-ons released and close to 1k updates in 2016. Amazing work everyone!

Before closing the year, the last thing I wanted to highlight is the most exciting thing to me and other open source enthusiasts: We are now finally fully in GitHub with all of our projects. Now we can use forks, clones, and pull requests all the way. Truly believe, this makes development much easier and I also hope to see your name added in the contributors list.

See you in 2017!

TestBench 4.2 is out with new convenience methods

TestBench 4.2 brings you a very nice improvement for screenshot testing, a few convenience methods, easier configuration of parallel testing, and bug fixes.

Taking screenshots of individual elements

Using the screenshot testing feature of TestBench makes it easy to validate that your custom application theme is working, or that any large group of components are visually in a desired state. Just call testBench().compareScreen("yourImageName") and TestBench compares the test screenshot with the reference image you set up.

Taking screenshots of the whole application view is in many cases error prone, which means that you need to mask out the volatile parts of your views in the reference images. Masking means that you need to edit the reference image in an image editor and remove parts that you don’t want to have compared. Using the TestBench calculator demo project screenshot tests as an example, in picture 1, I have removed the calculator log part from the comparison by setting it as transparent.

Masking out parts of a screenshot reference
Picture 1. Masking out parts of a screenshot reference

TestBench 4.2 introduces screenshot comparison of individual elements. You can still compare screenshots of a full application, but now you can also query a single component or a layout and make the screenshot comparison only to that component.

Using the same calculator example, I can write

GridLayoutElement keypad = $(GridLayoutElement.class).first();

And the resulting screenshot can be seen in Picture 2.

Taking and comparing a screenshot of a single layout
Picture 2. Taking and comparing a screenshot of a single layout

Convenience methods

Writing more readable code with less characters is always nice, even in test code. TestBench 4.2 brings out a few new convenience methods.

If you found yourself repeatedly writing myWebElement.getAttribute("class").contains("my-style") you can now just write myTestBenchElement.hasClassName("my-style"). The added benefit of this is that hasClassName actually matches only the tested class name, when getAttribute("class").contains("my-style") matches also "my-style-variant” and “my-styles” etc. If you need to match all the style names of an element, you don’t have to write getAttribute("class") and receive a single String, but you can get them in a Set with getClassNames().

Finally, the ElementQuery.last() method allows you to select the last of the matched elements. Query $(HorizontalLayoutElement.class).id("dialog-buttons").$(ButtonElement.class).last() selects the last button in a HorizontalLayout having an id “dialog-buttons”. That’s comfortably shorter than before:

ElementQuery<ButtonElement> query = 
query.get(query.all().size() - 1).

Easier configuration of parallel testing with system properties

When doing parallel testing, you can now configure the test hub hostname with the system property -Dcom.vaadin.testbench.Parameters.hubHostname instead of using @RunOnHub annotation. Similarly, a different system property can be used to configure the test to be run locally on a given browser instead of in a hub. You can write -Dcom.vaadin.testbench.Parameters.runLocally=chrome instead of using the test class annotation @RunLocally(Browser.CHROME).

Having the parameters available makes it possible to configure test runs for different environments. You can, for example, use Maven profiles or set the system properties in CI server settings.

More reasons to update

There are some very useful additions to the TestBench Element classes (see release notes). Maybe the most anticipated one is the ability to get number of rows in Grid by calling GridElement.getRowCount().

TestBench 4.2 also adds a bunch of bug fixes. My favourite fix is adding some missing waitForVaadin calls, which forced me to do explicit waits in some cases of my test code. All-in-all 4.2 is a good minor release. I highly recommend updating.

Vaadin TestBench 4.2

Vaadin 8 beta is out - we need your help!

Update: We are now in RC state, help us to iron out the last bugs before first stable release!

I’m happy to announce that the first beta version of the next major Vaadin Framework release is out. As discussed earlier, version 8 is a huge step forward taking advantage of the greatest and latest Java features. We have worked hard to make some of the core concepts in Vaadin Framework faster, simpler and safer to use, but now we need your help to make sure we haven’t broken essential features and to make the new features even better!

The most exciting new features are:

  • Modern typesafe API optimized for Java 8. The most relevant changes in
    • displaying data in select components and grid
    • binding data to fields
  • Faster (CPU) and more memory efficient data binding
  • Easier to implement custom form fields
  • Java 8 now supported for developing client side extensions as well
  • Improved defaults - less boilerplate code

Refer to the release notes to see the full list of changes. You can also see some code examples from the previous alpha release post and from the preliminary data binding documentation. We are working on publishing a version 8 branch of the documentation side by side with the stable documentation.

Although some of the core concepts have been completely renewed, upgrading to Vaadin 8 is still pretty easy. All old field implementations and selects using Container-Item-Property style API are still there, but moved to a separate compatibility package. We also provide an easy to use script that will change your code to use components from the compatibility package. Then you can start migrating to new more efficient APIs view by view or just use in the new code you write.

To move faster with the development, we needed to drop support for some legacy technologies. From Vaadin version 8 forward, only Java 8 is supported. Also, your application server needs to support Servlet 3 specification. Vaadin 8 also drops support for some older browsers. If you are using Internet Explorer, it has to be version 11.

How to try it out?

The new project wizard in Eclipse plug-in dialog doesn't work yet with the beta release. The easiest way to try out Vaadin 8 with fresh projects is to create a project using Maven archetype:

mvn archetype:generate  \
   -DarchetypeGroupId=com.vaadin  \
   -DarchetypeArtifactId=vaadin-archetype-application  \
   -DarchetypeRepository=  \

Once you have the project ready, just import the project to your favourite IDE. The pre-releases repository also contains compatible integration libraries for CDI and Spring, both with version 2.0.0.rc1.

Alternatively you can try out the upgrade script for existing applications:

  1. Download the jar file
  2. Execute the script from project root: java -jar path/to/your/framework8-migration-tool-8.0-SNAPSHOT.jar
  3. Add pre-releases repository to your project, see releases page
  4. Change project dependencies:
    1. vaadin-server to vaadin-compatibility-server
    2. vaadin-client-compiled to vaadin-compatibility-client-compiled if you are using DefaultWidgetSet
    3. If you are using CDI or Spring, update related Vaadin libraries to 2.0.0.beta1
  5. Recompile the widgetset if you are using add-ons

Let us know what you think

We have been working hard on the stuff and want to push it out as a stable release soon. Thus I encourage all Vaadin users to try out the new beta release and give us some feedback of every concern you have. There are probably still bugs and API decisions we haven’t thought well enough, so now is the time to get those fixed.

Let us know what you think and let’s make this the best Vaadin release so far. Report all findings through GitHub or forum. Big thanks in advance!

Release notes for Vaadin Framework 8.0.0.rc1