Close

Community Spotlight - September 2016

Do the words JProfiler or Install4j sound familiar to you? Well, they are both popular products developed by ej-technologies and for this month’s Community Spotlight, I had the pleasure of talking with one of its founders, Ingo Kegel. Ingo and his team used Vaadin to develop the front end of their new product, Perfino, a promising JVM monitoring tool for production servers. Ingo is also a very active member of the Vaadin Community, having published a couple of add-ons, one of them recently merged into the core of Vaadin.

ingo.png

Hello Ingo, it’s great to talk with you! I was really looking forward to it.

Me too! My Vaadin-based monitoring tool Perfino 3 has been released last week and I'm ready to talk about it and my general experience with Vaadin.

Congrats! I played with the demo and the UI components on it look familiar to me… what can you tell us about it?

Screen Shot 2016-09-26 at 13.11.37.png

Indeed! Vaadin is a very good fit for the Perfino UI which falls into the "admin UI" category. There is a lot of data in the backend in our case and the easy incremental delivery of data to the browser makes it very performant for large tables. Perfino is a relatively new tool but it's now reached a mature state in version 3. We've used the experiences of our first customers to improve the tool and we're really confident that Perfino delivers excellent value. It's very easy to set up, has extremely low overhead and a really simple and transparent licensing scheme.

What kind of technologies are you “mixing” with Vaadin in Perfino?

Perfino has a couple of separate parts. The most important part of Perfino is the agent which does not have any third-party dependencies apart from ASM. The collector is totally separated from the UI, and its most important external technology is a database. In the UI server we do not use any frameworks except for Vaadin. One important external client-side component is yFiles for displaying call graphs, which I integrated as a Vaadin Javascript component.

Would you say that development is simpler when your UI code is next to your backend code?

In a sense, the UI code in Vaadin is both frontend and backend code at the same time, so yes, eliminating the transport layer between browser and server is priceless in terms of developer productivity. Our real backend is the collector which is not coupled to the UI, because it must be able to run in a separate process.

How do the frontend and backend communicate in Perfino?

Via RMI, but that's only optionally the case if the collector needs to run in a DMZ. Usually they run in the same process.

What about the persistence layer? What technologies do you use there?

Plain SQL. We need every extra bit of performance and we need total control over what is executed on the database. Persistence layers are great for applications with data from complex business domains, but not in our case.

Why did you decide to use Vaadin for Perfino?

I compared a lot of frameworks, mostly client side based ones. Vaadin seemed like a silver bullet for me in how it combined backend and frontend development into a single layer, so I went with it. I'm fluent in Swing programming so learning Vaadin was extremely easy. Mostly, my expectations have been met and I feel like the time for developing complex UIs is an order of magnitude shorter than it would be with some client-side frameworks. Of course there are drawbacks, but they are not especially significant for me. For example, when you want to "break-out" of the framework and extend it yourself with new client-side functionality, you have to understand the orchestration that goes on behind the scenes. But if you go with what the framework offers, you really don't have to do that.

And in fact, you indeed digged into the code and now are a committer of the Vaadin framework itself. What’s the story behind this?

Well... nearly every web application needs a login form and I rely on the browser to save my user credentials and auto-fill the form for me. With Vaadin, this was not so easy. When you click on a button, the interaction goes through a server-side loop and the browser does not see a direct submit of a form. Vaadin had a special login form component before, but then modern browsers became more restrictive and it stopped working and eventually it was deprecated. So I decided to develop my own login form component as an add-on. A couple of Vaadin versions later, that add-on was merged into the core in place of the deprecated component.

Awesome! It was a pretty popular add-on with more than 20.000 downloads and now available out-of-the-box. I bet you received a lot of positive feedback.

The user feedback was very helpful in getting it work in all kinds of different situations. As a single developer you sometimes only test things in one way - for example, I always closed the auto-complete drop-down with the enter key, but the tab key did not work for auto-completion, as another user pointed out. So this open development benefits my users, as well as everybody else.

Yes, that’s one of the advantages of having an active community in open-source projects. Vaadin has been around for more than 15 years already, but what’s your personal view of the future of Vaadin in contrast with pure client-side frameworks?

Well, I don't see how advances in client-side-only frameworks could threaten Vaadin. And with its web components strategy, Vaadin seems to have an interesting angle for breaking into the client-side only development. I'm personally looking forward to the immensely improved data-binding in Vaadin 8 and I hope that Vaadin will continue to work on the Grid component and add lots of features to it, for example hierarchical support.

Well said! Thank you Ingo not only for your contributions to the Vaadin framework but also for sharing your thoughts in this interview. Best wishes with Perfino and your future projects!

Thanks a lot Alejandro! Bye!

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