Vaadin community survey - learn more about our users!

Vaadin today has an active community of over 150 000 developers, which is why it’s vital for us to know more about you so we could serve you better. In order to do this, we ran a community survey in August with over 15 questions. Over 250 of you answered so let’s have a look at what you said.

Part I: User & company profile

What best describes you?

This is a crucial question for understanding the priorities and challenges of our users. The majority of you are Software Developers (49%) and Architects (32%), responsible for the technology decisions and implementation of new features in your projects. The rest 19% are made up of Designers (8%) that are in charge of the look and feel of the product’s design, and Managers (6%) that are responsible for the coordination and success of the product. Overall, this spread of roles is what we would have expected, as our community is heavily made up of developers and technical people.

PersonType.png

What best describes the company you work for?

This question has been asked in two parts: what is the industry and the size of the company that you are working for.

Let’s start with the company size. As it can be seen below, almost one in three respondents run a Startup company, taking 35% of the share. The second place was shared between Small companies (22%), Mid-size companies (23%) and Large companies (20%). It is great to see a diversity like that among Vaadin users as it proves that Vaadin fits both smaller and larger companies in different stages.

CompanySize.png

The second part of the question covers the company’s industry. It has been challenging to segment our respondents based on the industry, because nowadays many companies have two (or more) areas as their core competences, e.g. IT and Healthcare. As it can be expected, the majority (77%) of our respondents are working in Computer software industry, either making ready-made software solutions for other companies or performing consulting and building software on demand. Those companies are building software solutions for different industries, including Banking & Finance, Healthcare, Public sector, Logistics & supply chain, Retail, Telecommunications and other. It was excellent to see a confirmation that Vaadin is suitable for all companies of different sizes and industries.

Type-3.png

With this background info about you, we wanted to know more about your technology stack as well.

Part II: Technology choice

Which JVM language do you use most often?

As it can be seen below, Java is leading over other JVM languages, taking up 96% of the total vote. Groovy and Scala are responsible for 2% and 1% of the votes respectively. Kotlin and many others contribute to the remaining 1%. This was somewhat a surprise to us – might it be that plain-Java users are just more eager to answer surveys? :)

Language.png 

Which Java version do you use?

We can see that 74% of the respondents stated that Java 8 is used to run their main production applications. 21% of the respondents are on Java 7  and the rest - 5% are using Java 6. Java 8 really is the way to go when going forward.

JavaVersion.png

Which IDE do you use most often?

According to the survey, Eclipse is still the most popular IDE among the Vaadin respondents, taking 60% of the vote. Next in line is Intellij that is used by 29% of the users. NetBeans, as the last of the bunch, still has a solid 11% of the votes.

It’s also nice to notice that the Vaadin Plugin for Eclipse is used by 40% of Eclipse users. One of you mentioned Vaadin Designer inside the plugin as a reason to its popularity: “The plugin for Eclipse is so simple and intuitive that I was able to develop the layout of complex applications in minutes”.

These results are different from a recent JRebel survey (Java Tools and Technologies Landscape Report 2016). According to their studies, IntelliJ is the number one IDE (taking 46% of the votes) for Java developers for the first time. We suppose that it might be because Vaadin has supported the Eclipse plugin for a longer period of time.

IDE.png

How is your backend developed?

Front-end and back-end development work in tandem to create an application for users. That’s why it’s important for us to learn how the backend of an application is done in each case. As it can be seen below, Java EE is leading over other ways of development, taking up 41% of the total vote. Spring is used in 31% of the cases. The rest 27% includes a custom-made backend and other options.

Backend.png

Part III. Comments & suggestions

Would you recommend Vaadin to you friends or colleagues?

It is very essential for us as a company to understand how our users are perceiving Vaadin and if they would recommend it to their friends and colleagues. We asked this question using the NPS (Net Promoter Score) scale, where 1  is very unlikely and 10 is very likely. We're happy to see that as many as over 82% of you gave Vaadin Framework a 7 or higher!

Your feedback to Vaadin

It was superb to receive so many comments and suggestions in our last section - feedback to Vaadin. It was pleasing to see that many Vaadin users are positively motivated about Vaadin. Here are some quotes:  “As a Java guy I consider Vaadin to be the best Java web framework at the moment. It's pros are elegant UI design (themes) and clear and evident approaches behind everything” or as another one of you puts it “It's simple and productive… Today I start the project scribbling on paper and within minutes already have an application running in the browser. This was certainly the greatest motivation of technical leaders to adopt the framework.

While it was great to have such a positive feedback, we also received a lot of improvement ideas and suggestions. Some users were proposing to have more “out-of-the-box” examples and tutorials. Others were recommending to have additional tutorials for different IDEs, such as IntelliJ and Netbeans. A few respondents mentioned that Vaadin’s public roadmap should be more transparent with a clear explanation of the company’ priorities and future steps.

There were many other priceless comments that will be taken into consideration. You’ll hear something about all of the mentioned things very soon!

Once again, we are extremely grateful for your contribution, your honest information, and if you still haven’t filled in the survey, please do so now at vaadin.com/survey

 

Vaadin Framework 8 comes with Java 8 native APIs

For a web framework whose history spans back 15 years, Vaadin Framework contains an insane number of modern web technologies. It has been an SPA (single-page application) before the term was coined, it uses WebSockets for a constantly open communication channel, Sass for enhanced theme building and you can easily wrap a WebComponent based JS widgets with a clean Java API for use in Vaadin applications.

We have been really active taking in all the new stuff that has become possible regarding web as an application platform, but we have been rather conservative in taking full advantage of JVM and Java, which has also developed with leaps. In Vaadin 8, we focus the core of the product, the Java API that you use to build your awesome UIs, and make that faster and easier to use.

Most of the API in Vaadin is still valid and perfectly functional. You can even use e.g. lambdas with certain features, but it has been designed in an era with no generics, lambda expressions, method references and even without a proper java.util.collections package.

Getting rid of millstones around our neck

Oracle has dropped their support for Java 7 and IBM has a modern Java 8 support, so nobody on Earth should be using Java 7 or 6. But we know there still are people who are using them. To make big leaps forward we need to let something go. Vaadin 7 will still be supported for the minority of Java developers who are still bound to old Java versions, for one reason or another.

Also, we will be dropping support for some old browsers, most notably IE 8-10. If Microsoft thinks nobody should use them, so should you. We know this is rough for some users, but we just need to go forward. This will make us much more agile to develop our components in upcoming versions.

Backwards compatibility, in terms of API compatibility, is another thing that might make you a bit afraid of the upgrade as well. We won’t promise a 100% backwards compatibility as we want to clean some old methods from our components, but we’re making a special backwards compatibility module which will make upgrading to Vaadin 8 much simpler than the previous Vaadin 6 to Vaadin 7 upgrade.

Data binding renewed - less and simpler code

Most of the renewals in Vaadin 8 will be related to “data binding”: how to connect data to tabular components, how to populate options in select components and how to bind business objects to field components in forms.

Previously Vaadin developers used a lot of proprietary interfaces called Containers, Items and Properties to do the databinding. In the early days of JVM this was a good idea, but in the modern era of Java, most Vaadin developers just wrap their lists of beans using a helper class called BeanItemContainer, and give that container to e.g. Vaadin ComboBox component. In Vaadin 8, we just pass the beans directly to the component.

Also, with previous versions, if there was some customization needed for the presentation, either a custom DTO or tricky work with the Container-Item-Property stuff was needed. Now, you can often change the presentation with a single lambda expression.

The following common use case, implemented with both Vaadin 7 and a pre-release of Vaadin 8 emphasises how dramatic a difference the “containerless” modern API can make:

Before:

ComboBox comboBox = new ComboBox();
List<Contact> contacts = service.findAll();
BeanItemContainer<Contact> beanItemContainer = new BeanItemContainer<>(Contact.class);
GeneratedPropertyContainer gpc = new GeneratedPropertyContainer(beanItemContainer);
gpc.addGeneratedProperty("name_combined", new PropertyValueGenerator() {
   @Override
   public Object getValue(Item item, Object itemId, Object propertyId) {
       String firstName = (String) item.getItemProperty("firstName").getValue();
       String lastName = (String) item.getItemProperty("lastName").getValue();
       return firstName + " " + lastName;
   }

   @Override
   public Class getType() {
       return String.class;
   }

   @Override
   public Container.Filter modifyFilter(final Container.Filter filter) throws UnsupportedFilterException {
       final SimpleStringFilter ssf = (SimpleStringFilter) filter;
 
       return new Container.Filter() {
           @Override
           public boolean passesFilter(Object itemId, Item item) throws UnsupportedOperationException {
               final It/nem generatedItem = gpc.getItem(itemId);
               String fullname = generatedItem.getItemProperty("name_combined").getValue().toString();
               // Ignore case as ComboBox
               return fullname.toLowerCase().startsWith(ssf.getFilterString());
           }
 
           @Override
           public boolean appliesToProperty(Object propertyId) {
               return "name_combined".equals(propertyId);
           }
       };
   }
 
});
comboBox.setContainerDataSource(gpc);
comboBox.setItemCaptionPropertyId("name_combined");

After:

ComboBox<Contact> comboBox = new ComboBox<>();
comboBox.setItems(service.findAll());
comboBox.setItemCaptionProvider(c-> c.getFirstName() + " " + c.getLastName());

Simpler, faster and more readable, that is the code you write with Vaadin 8.

When building forms, in the future you’ll use a concept called BeanBinder, which directly accepts your domain objects. The BeanBinder also contains a lot of cool improvements regarding form validation and makes it much easier to create top notch UX for your end users. The new BeanBinder also gives you much more control to customize how your form works, like where and how to present validation errors. The validation can be executed dynamically, as the user is still typing in, and enabling the primary action only when it can actually be executed. The BeanBinder has full support for cross field validation using JSR 303 validators and you can define your validation rules as a single lambda expression.

The code example below shows how to bind a phone number and email TextField to a Contact bean, with slightly different methods and custom validators.

final Contact contact = new Contact();
 
final TextField phone = new TextField();
final TextField email = new TextField();
Button save = new Button("Save");
 
final Predicate<String> requirePhoneOrEmail = v -> !phone.getValue()
       .trim().isEmpty() || !email.getValue().trim().isEmpty();
 
final BeanBinder<Contact> binder = new BeanBinder<>(Contact.class);
binder.forField(email)
       // cross field validation, both programmatic Vaadin specific
       // style and JSR 303 validators are supported
       .withValidator(requirePhoneOrEmail,
               "Both phone and email cannot be empty")
       // express simple validators using on line lambda expressions
       .withValidator(value -> value.length() > 3,
               "Email must be longer than 3 letters.")
       // or use some of the built in validators, like before
       .withValidator(new EmailValidator("Incorrect email address"))
       // bind to email property in Contact bean
       .bind("email");
 
binder.forField(phone)
       .withValidator(requirePhoneOrEmail,
               "Both phone and email cannot be empty")
       // bind with explicitly set getter and setter lambdas
       .bind(Contact::getPhone, Contact::setPhone);
 
// Trigger cross-field validation when the other field is changed,
// not needed with JSR 303
email.addValueChangeListener(event -> binder.validate());
phone.addValueChangeListener(event -> binder.validate());
 
binder.setStatusHandler(new BinderStatusHandler() {
   @Override
   public void accept(BinderValidationStatus<?> t) {
       // react to validity changes
       save.setEnabled(t.isOk());
   }
});

This is just the tip of the iceberg. There are many other exciting enhancements coming up. For example, a super easy way of connecting lazy loading components to data without a need to build a custom Container. We believe that Vaadin Framework 8 will make your life as a Java developer much easier.

Developer preview released at JavaOne

We have been working a lot on these changes and we are confident that we are on the right track. But at the same time, we also know we have been looking at these changes from a short distance - probably missing some important details about our API. Thus, we want your help! Even though a lot of things are still in flux, you can try out the next generation of Vaadin API today with 8.0.0.alpha2 and help us make web development easier than ever.

As usual, quite a few people from our team are at JavaOne. Come meet with some of the core developers who can answer even the trickiest questions related to the new versions. Visit our booth and the Vaadin Meetup at JavaOne to give us new ideas and get more insights of Vaadin 8!

See the in progress documentation for data model in version 8

 

Framework roadmap: Connecting the dots

Soon after we founded Vaadin 16 years ago, I started the habit of frequently blogging about roadmaps. The fact that I have been less vocal about our plans might seem strange considering that we have multiplied our investments in R&D at the same time. In total, we today have over 130 persons in Finland, California and Germany - both building Vaadin technologies and helping our customers use them.

We are working on multiple exciting things in parallel and they are all pieces of the same puzzle. Until now you have only seen one part and it may have been somewhat misleading. In fact, we have already gotten quite a few questions on how Core Elements and Framework are connected.

Here is the full story on what we plan to do next for Vaadin Framework. Please ask questions and give feedback.

Background: Purpose, passion and mission

From day 1 (July 1, 2000 to be exact) we have had two interconnected passions:

1) Help end-users’ lives by enabling developers to build great web applications that are fast, intuitive and work on any device. Applications that just work and your users will fall in love with.

2) Optimize the ease of development. For every line of code the developer does not have to write and maintain, they can focus on making the end-user experience better.

Our customers - 100% of them - are developing web applications and trust our technologies for their user interface. Our responsibility is to ensure that the platform they build on is rock solid and allows them to utilize the latest and greatest of the web for years to come. We are honored by that trust and take this responsibility very seriously. It is our business and purpose.

With that, our mission is simply to Make it easy to build the best web-apps for business.

A solid foundation: Vaadin Framework 7

7.0.0 was released in 2013 with an amazing list of new features: faster layouting, a new communication system, modular builds, deep integration with GWT, JavaScript as a first class extension language, HTML5 support, a Sass compiler, Bean validation and dozens of other features. This was a huge update and technology refresh.

But more importantly, it was the first step in a very active product iteration. It enabled us to release tons of new features in 7 minor revisions that maintain backwards compatibility. Just to name a few: Valo theme engine, extensible Grid, automated push communication that adapts to network conditions, font icons, WAI-ARIA support, a declarative layout language and cloud based widget sets. In addition, we built over 65 maintenance releases that solidified the framework to a very mature platform that top companies all over the world build their business critical applications on.

We are committed to maintaining Vaadin Framework 7 at least until 2018. With the easy migration path to the upcoming major version, the applications built with Vaadin Framework 7 will have a foundation that is supported until 2022 without a need for major upgrades.

Vaadin Framework 7 is one of the very few web frameworks with which you can build applications with a long lifespan expectancy - backed by a 16-year track record.

Simplified development with Java 8: Vaadin Framework 8

Stability and backwards compatibility have their downsides as well, we have not been able to utilize the new features in Java 8 and evergreen browsers to their fullest potential, as it would have forced us to drop support for old Java and browser versions.

Vaadin Framework 8 will bring two important changes, one functional and one non-functional one, but both equally important.

First of all, it will greatly simplify the data API by building on Java 8 lambda expressions and modernizing the design principles. Just think of writing something along the lines of this, instead of implementing the Container API:

countryGrid.setItemFetcher(
  q -> backend.fetchCountries(q.getOffset(), q.getLimit()),
  q -> backend.getCountryCount()
);

Naturally we will support the current data API for making the transition from 7 to 8 simple, but the new API should both make the framework easier to learn and you more productive.

Secondly, Vaadin Framework 8 drops support for technologies that are no longer maintained. By dropping support for IE 8–10 and Java 6–7, we are able to speed up rendering and build better APIs. Going forwards, we will support all modern evergreen browsers, IE 11 and Java 8+.

As a whole, Vaadin Framework 8 is a far less radical upgrade than Vaadin Framework 7 was. This is by design - with a major version we are able to drop old technologies that slow us and you down and at the same time keep migration easy.

Now the scary part (for the writer) - setting expectations for the timeline. We hope to release Vaadin Framework 8 before the end of this year.

Beyond 8 with Project Hummingbird

For the past two years we have been busy researching technologies that come after Vaadin Framework 8 in a project called Hummingbird. While we would have loved to be more open about it, we wanted to get the foundation right before getting everyone excited about it.

The questions we asked ourselves were:

  • Is there a technology on the horizon that will become so important in the web platform that it has potential to revolutionize all frameworks?

  • Why have client-side frameworks like Angular JS become so popular?

  • What are the limitations in Vaadin Framework and how would we be able to remove them?

Answers to these questions formed foundational technologies that we started developing and will be bringing to Vaadin Framework users:

Web Components will shortly be fully supported by most ever-green browsers. Chrome is leading the pack, but other evergreen browsers will follow shortly. They bring the component oriented programming paradigm that Vaadin has promoted for over 15 years to the web platform and will potentially revolutionize and unify front-end frameworks. This provides us with two opportunities:

1) Web components are a perfect rendering model for Vaadin Framework. Imagine using any web components by any vendor from server-side Java, just like you use server-side Components today. This will significantly expand the number of available components. You will get a new powerful extension and rendering model without sacrificing the simplicity of the server-side Java development model.

2) We will be able to share the components we build with other frameworks. Anyone could use Vaadin’s components - not just Java developers. Teams committed to using React, Ember, Angular or anything else would benefit. And for the end-user, the UI built by these frameworks would seamlessly integrate with UIs built with Vaadin Framework. Everyone would win. We have already started to release some of these components as in the form of Vaadin Elements.

Templates are the magic sauce in modern front-end web frameworks that make them powerful. By bringing template language to Vaadin Framework, one can build application views and new re-usable components by writing some HTML and binding it to data directly. And this is what we are building for Vaadin Framework - except that you can also bind to server-side data and mix in current components. This should make everything that is hard today in Vaadin Framework easy - without compromising what is easy today.

Web Sites have been outside the scope of Vaadin Framework. For building one, you have most often wanted to combine Vaadin Framework with some other framework - for example Spring MVC. This is by design, Vaadin is meant for building web applications. In the future we expect the border between an app and site to be fading away. So we set ourselves to resolving the technical limitations and thus making Vaadin Framework a great foundation for building dynamic sites. Without compromising its power for building web apps.

We hope to open up these technologies for Vaadin Framework users to test early next year as “Project Hummingbird”. Later next year we plan to integrate them to the upcoming Vaadin Framework 9 with a clear migration path from version 8.

Solid foundation keeping up with the latest technologies

As a summary, Vaadin Framework 8 will bring full Java 8 support before the end of the year and we’ll continue after that by integrating Vaadin Core Elements, templating and a better support for building dynamic web sites. With this the dots are finally connected and there are great things ahead for you as a Vaadin Framework 7 user.

Looking both backwards and forward, it has never been a better time to start building applications your users will love with Vaadin Framework.