Technical Articles on Flowing Code

Introducing AppJars: Production-Ready Modules for Java Enterprise Applications

Tue, 25 Aug 2026 20:48:23 +0000

Over years of building enterprise applications for clients across many industries, we kept running into the same thing. Before a team can write the part that makes an application unique, it spends weeks, sometimes months, rebuilding the same foundations: user management, audit trails, reporting, translations, email, background jobs. Necessary work, and rarely the reason the project started.

Google Maps Add-On: Mobile Right-Click for Markers

Tue, 18 Aug 2026 14:16:43 +0000

In modern web development, creating a consistent and intuitive user experience across all devices is essential. Users expect features to work seamlessly, whether they’re on a desktop with a mouse or a mobile with touchscreen.

Building a Vaadin Add-on in Record Time with Claude AI

Tue, 21 Jul 2026 13:39:02 +0000

Not long ago, I shared my experience on how to migrate a legacy Vaadin application with the help of Claude AI. That experience proved that AI is fantastic for untangling legacy code, but it left me with a new question: What happens when we start from scratch? Recently, my team at Flowing Code proposed creating a new add-on: a Vaadin wrapper around the @github/relative-time-element component. This time, I decided to keep Claude in the loop from minute zero, not just as a code generator, but as an architectural design partner.

Why Vaadin Still Matters in 2026

Tue, 30 Jun 2026 13:40:16 +0000

In an industry obsessed with the new and shiny, asking why a technology continues to thrive can be more interesting than asking what will replace it next.

Vaadin is not a newcomer. Its development started in the early 2000s, and it became open source in 2002. Over the years, it has gone through several major architectural changes while remaining actively developed and widely used in enterprise applications. In a space where frameworks often come and go within a few years, that alone makes Vaadin worth reflecting on.

Vaadin 10 to 25: Migrating a 8-Year-Old App with Claude AI

Thu, 18 Jun 2026 19:49:25 +0000

Back in 2018, our team at Flowing Code built a quick, scrappy demo to show off the then-brand-new Vaadin 10. It was a hackathon project built around the major global football tournament happening in Russia at the time. The app was designed as a live dashboard tracking match fixtures, real-time scores, and group standings.

9 Years Flowing Strong

Wed, 29 Apr 2026 20:03:48 +0000

Time really does fly when you are deeply immersed in doing what you love. It feels like just yesterday we were reflecting on our early milestones, and this month, we are proudly celebrating our 9th anniversary. This past year at Flowing Code has been defined by tackling complex technical challenges, driving major platform upgrades, and strengthening our commitment to both our enterprise clients and the open-source ecosystem.

Vaadin 25: How We Solved JSON Migration

Fri, 19 Dec 2025 18:59:32 +0000

Vaadin 25 was just released, and it comes with an interesting set of breaking changes to keep us entertained and wide awake as we head into the year’s final stretch.

At Flowing Code we maintain more than 30 add-ons, and most of them currently support Vaadin 14, 23, and 24. As you can imagine, this makes the Vaadin 25 migration cycle a substantial effort. And our goal is ambitious: keep a single codebase compatible with all supported Vaadin versions, without branching off into Vaadin-25-specific releases unless absolutely necessary.

A Path of Learning, Commitment, and Continuous Improvement

Mon, 01 Dec 2025 12:21:26 +0000

On August 1, 2025, at Flowing Code S.A., we reached a new milestone: we successfully achieved our first recertification of the ISO 9001:2015 standard, having successfully passed the audit conducted by TÜV Rheinland. Beyond the certificate itself, what we are celebrating is the entire journey we took to get here.

Improving Code Reviews with AI: Our Experience with CodeRabbit

Thu, 13 Nov 2025 12:42:55 +0000

It seems like everyone is using AI these days. From chatbots to code generators, the wave of tools promising to make developers’ lives easier keeps growing. At Flowing Code, we wanted to see how AI could actually help in our day-to-day work, not just in theory, but in practice. After some investigations and considerations on what could be improved in our daily tasks, we decided to dive into the AI world with CodeRabbit, a tool designed to help review Pull Requests.

Shaping the Flow: 8 Years of Innovation and Evolution

Wed, 30 Apr 2025 21:58:37 +0000

As Flowing Code celebrates its 8th anniversary, we stand proud of a journey marked by steady growth, evolution, and meaningful impact. Year after year, we continue to strengthen our foundation—delivering high-quality software solutions to our clients while nurturing a thriving open-source community. Our commitment to innovation, technical excellence, and collaboration has not only propelled us forward but also deepened our purpose: to create value through software that empowers, simplifies, and inspires. This past year has been a testament to our resilience and our vision, as we expanded our client work, launched new open-source extensions, and laid key groundwork for the future of enterprise development.

Our Commitment to Open Source: Releases and Updates in 2024

Tue, 17 Dec 2024 15:15:31 +0000

If you keep up with our work, you may already know that here at Flowing Code, we’re passionate about contributing to the Open Source community and dedicated to delivering solutions that can help developers to build better applications. This year, as part of that commitment, we’ve successfully released eight new Vaadin add-ons. If you haven’t had a chance to explore them yet, let’s take a quick look at what each of these add-ons offers.

Sustaining Excellence: Our Journey of Continuous Improvement

Thu, 05 Sep 2024 20:29:08 +0000

At Flowing Code, our commitment to excellence drives every aspect of our work. This dedication has once again been validated as we successfully passed our third external ISO 9001:2015 audit without any non-conformities. This achievement reflects our continuous improvement effort to enhance and adapt, ensuring that we not only meet but exceed the standards expected of us. Over the past year, we have focused on enhancing our internal development processes, expanding our organizational structure, and aligning our operations with our environmental responsibilities. This blog post outlines the key improvements we’ve made and expresses our gratitude to those who have supported us along the way.

Introducing our first Vaadin add-ons integrating React Components

Thu, 15 Aug 2024 18:24:30 +0000

Vaadin 24.4 brings exciting new capabilities for integrating React into Vaadin applications in various forms. This offers developers a range of integration options, providing unprecedented flexibility in building modern web applications. You can delve into the various possibilities and the reasons behind this improvement in Vaadin’s blog post.

Google Maps Add-on: How to Get and Track Current Location

Thu, 18 Jul 2024 13:14:01 +0000

The Google Maps Add-on is a powerful wrapper component around the Google Maps Web Component. This add-on allows you to display a customized map and incorporate various map-related elements such as markers, polygons, custom controls and more. You can explore all the features the add-on provides in our online demo. For now, we’ll focus on how to obtain and track the user’s current location.

Time & Material vs Fixed Price? Why We Prefer the Flexible Approach

Mon, 10 Jun 2024 13:55:09 +0000

When it comes to software development contracts, businesses typically face a choice between two common pricing models: time and material, and fixed price. These frameworks offer distinct approaches to budgeting, project scope, and risk management. In this blog post, we’ll explore the differences between these two models, outlining their respective advantages and drawbacks. This discussion will help clarify why our company has chosen the time and material approach and offer insights into how it aligns with our business values and project management style. Stay tuned as we delve into the nuances of these pricing strategies and share the reasons behind our decision.

A Guide to Using Badge List Add-on

Thu, 30 May 2024 13:50:53 +0000

Introducing Badge List component, one of our latest Vaadin add-ons, created to address the challenge of displaying a dynamic list of badges within a confined space, such as a Vaadin Grid cell, in a responsive and user-friendly manner.

Adapt, Evolve, Thrive: Flowing Code’s 7th Year in Retrospect

Thu, 25 Apr 2024 19:17:34 +0000

As we mark the 7th anniversary of Flowing Code, it’s a special time to look back on our journey. Each year, our company grows stronger, fueled by our commitment to innovation and delivering exceptional work. We’ve faced challenges, seized opportunities, and kept moving forward with determination. Our success isn’t just about the projects we do for our valued clients, but also about the active community we’ve built through our open-source projects. Looking back on the past year, we’re proud of what we’ve achieved, from impactful client projects to the cool extensions we’ve added to our GitHub repository. As we look to the future, we’re thankful for the chances ahead and are excited to keep delivering top-notch solutions for our clients and the wider community.

Flowing Forward: A Look Back at Flowing Code’s 6th Year

Wed, 05 Apr 2023 14:14:10 +0000

As we mark another year of existence at Flowing Code, we continue to push the boundaries of software development, delivering innovative solutions and services to our clients. Over the past year, we have faced numerous challenges and opportunities, and we are proud of how our team has risen to the occasion, adapting and evolving to meet the ever-changing demands of the industry. In this review, we take a look back at some of the key highlights and accomplishments of our 6th year.

We’re an ISO 9001:2015 certified company!

Tue, 06 Sep 2022 15:31:44 +0000

I am glad to announce that in June we successfully passed the external audit that evaluated the conformity of our Quality Management System with the requirements of the International Standard ISO 9001:2015.

Installing Vembu BDRSuite with Docker Compose

Mon, 11 Jul 2022 12:55:25 +0000

In these days we tend to think that just by having our services and data on the cloud everything related to backups is solved and is someone else problem. But for most of the companies this is not enough, and if we’re in charge of defining the infrastructure of an organization we should consider implementing several layers of backups no matter where the data is actually hosted.

How to use Angular Components with Vaadin

Mon, 04 Jul 2022 15:19:43 +0000

If you’re familiar with our work, you know that we’ve created a few components to be used in Vaadin Flow applications based on existing Web Components or in JavaScript libraries that we found interesting. But what about if you want to use an Angular Component and create a Vaadin component from that? Would that be an easy task? I didn’t have an immediate answer for that question so I did some research, a lot of testing and here are my findings.

Using our AppLayout Addon in a Hilla Application

Mon, 23 May 2022 20:31:00 +0000

First of all, just a little bit of context for those who haven’t heard about Hilla yet. What’s the fuss about it? It is a framework for building reactive client-side web apps. With reusable web components and simplified, secure, and type-safe access to the Java backend, it allows you to stay more productive than with minimalistic frontend frameworks. Hilla apps are built on web and industry standards, making them more stable than the alternatives. If you want to know more, the best starting point is the official site. For a more concrete view, you can watch this video that analyzes the library and goes through the steps for creating a quick example.

Last year in review: 5 rounds keeping the code flowing

Fri, 01 Apr 2022 12:50:58 +0000

April 2017 marked the time where Flowing Code started to exist. Since then we’ve been learning, investigating, coding, delivering high value to our customers and also, maintaining a growing community. As we celebrate reaching this amazing milestone, here is a quick review of our last year.

Display realtime crypto prices with Vaadin and Spring Reactive

Mon, 14 Mar 2022 12:47:38 +0000

In this article, we’re going to create a simple application to display crypto currencies trades price in realtime using Vaadin Flow and Spring Reactive WebSockets API.

Vaadin TreeGrid with lazy loading, filtering and sorting

Thu, 13 May 2021 14:12:58 +0000

I’m giving my first steps into Vaadin 14 after a long, long time of Vaadin 8 projects and I want to share my experience when it was time to work with the TreeGrid component to display hierarchical data. I ran into this issue where I needed to add filtering and sorting to a Vaadin TreeGrid implementing lazy loading. I had this article for Grid as base but some things are different so I thought it would be a good idea to share all the steps needed and all things to keep in mind for this kind of implementation.

Another year in review: The new normal

Mon, 05 Apr 2021 20:03:58 +0000

Our life, way to enjoy, live and work has changed, but we’re still here giving our best to provide the quality services that our customers demand. Let’s review another year by going through our most remarkable achievements.

Our last year in review: #StayHome & Code!

Tue, 14 Apr 2020 20:14:10 +0000

Although we’re all navigating uncertain times and the reality of the world is very different from what it was one year ago, Flowing Code is turning 3 years old and we wanted to take a moment to acknowledge all the good work and growth we managed to achieve. So here’s little review of our last year:

CSS Theming & Styling in Vaadin 14

Thu, 22 Aug 2019 14:10:00 +0000

Last week, the new LTS version of the presentation framework was announced.
While you can find more information about the new features in the official site, I would like to focus on one specific feature that I’ve found interesting: styles management.
Across the years we saw different approaches in how to handle styles in Vaadin applications.
In Vaadin 6 you could just modify styles using plain CSS. Of course you had two choices: either build everything from scratch, or inherit the built-in themes like Reindeer, Runo or Chameleon. That inheritance scheme was based in the @import css statement, which is the basis of the cascading part of the theming technology.
The problem with this approach was that the customization was difficult, because the complexity of the rendered DOM, and the lack of variables that could help in modifying certain aspects of the base themes such as sizing and spacing, that several rules had in common.

Lazy, Filtered and Sorted Vaadin Grid using External Data Source

Wed, 24 Apr 2019 18:06:00 +0000

In large enterprise application development projects, it’s usual to code use cases that, as the main requirement, define to show the user huge amounts of data in a tabular way. For this kind of scenarios, there is a particular web component that comes really handy: a Grid. Given that we like Vaadin’s framework, we are going to describe how to configure it in such a way that doesn’t restrict you about performance issues when doing that.

This post assumes that you have some knowledge of web application development using the Vaadin Framework and the Java Platform. But we’ll try to explain everything as much as possible. The version that we used to write this application is Vaadin 13, but this part of the API is almost the same since Vaadin 8, so it should be possible to use the same approach in older versions.

Setting up a Vaadin Grid, is really easy, just create an instance and then customize the columns, or even skip that part if your Pojo is sufficiently self-descriptive.

As an example, let’s assume that we want to show a grid with data for a person, which we can define as a simplified entity like this:

Our 2nd year in review: keep flowing!

Wed, 03 Apr 2019 21:21:00 +0000

Another round around the sun, another term ended, and here we are still moving on. A lot of things happened since this team was created, and many of them last year. Here’s a quick review of what we did:

Traveling

Let’s start with one of the best experiences we got the chance to share as a team. We had the opportunity to visit the northern hemisphere to meet our friends at Vaadin’s main HQ.

While we were there, we shoot some awesome pictures, visit some interesting places and had the amazing chance of getting to know all of the experts behind the company that is responsible for this great open source framework.

Sharing

Talking about Open Source, we continued to support our community, and created a special section in our web site to group all of the projects that we maintain.

We worked hard to develop a bunch of interesting projects, giving away our best effort to make them production ready, so anyone can use our technologies in their projects, and participate with us actively so they can improve over time.

One interesting project to mention, was a small PWA application that displayed the results of the Football Worldcup in real time, showing how to integrate several technologies, so similar projects can be built using this a kickstart.

Learning

Delivering intelligence is not an easy task if you don’t find a way to expand your knowledge. We take this statement seriously: we schedule one learning day each week, so we can watch, learn and discuss about many technologies, methodologies, frameworks, languages, etc.

Here’s a list of the subjects and some interesting links for you to watch if you’re curious:

Creating a Vaadin Flow Server-Side API for a Javascript component

Tue, 08 Jan 2019 19:50:00 +0000

Today we are going to explore some tips about how to create a Java server-side wrapper for a regular javascript component using Vaadin Flow. As you might notice, this popular framework has good documentation about how to integrate an existing Polymer Component, but there is no much info about how to integrate a regular Javascript component, so we will show you one easy approach of doing that.

What we want to do is, to show you how to create a nice Java API around a typical javascript component, so you can easily integrate it in your java applications.

Of course, there are many ways to build javascript visual components around there, we will focus on the ones that use this common pattern: you create a html element (like a Div), and then you instruct the library to “enhance” it.

Then we have one important feature that is usually wanted: bidirectional communication between the server and the client.

For this short tutorial we want to build a Vaadin Flow wrapper around one interesting library that is able to draw time line graphs: vis.js. This library is based on the previous premise: to enhance (in this case) a div html tag.

Let’s start.

Step 1: Overview of your component

First, it’s a good idea to use a starter to build a project based on Vaadin. We will use this one, which is perfect for creating a new component. Because it’s mandatory to specify a base GitHub project, just leave the one that is offered, you can change that later.

We want our component to be easy to use; hence, following Vaadin conventions, we will create a simple class that will extend a Div component. This class will be able to render the component in the client side, exposing some methods that will give the developer the ability for interacting with it in several ways:

Planning your SCM strategy

Tue, 18 Dec 2018 18:28:00 +0000

We have been frequently asked by companies that are planning or are developing a software product about the common issues found trying to achieve a good production workflow, good teamwork and the security of properly handling the code base.
During our years of expertise we developed a strong vision about the most important tools that you need to use if you want to build software in a controlled way.
These tools encourage the implementation of a Software Configuration Management (SCM) strategy within your organization. In turn, this will have a great positive impact in many aspects, some of them technical, but also in many functional and workflow oriented ones.
Today most of software engineers take these tools for granted. But there are cases where companies with small development teams or organizational debts need some help figuring out these stuff. In that spirit we are writing an overview of this topic.
Most of the important problems that could come up are solved by properly installing, configuring and using this tools.
One key fact is that these tools are important regardless of the language or platform that you’re using.

Developing modern web-apps with Vaadin @ UNL

Mon, 24 Sep 2018 20:01:00 +0000

Last Wednesday we gave a presentation in Universidad Nacional del Litoral, where we explained some concepts related to developing web applications using the latest version of the Finnish platform.

Vaadin 10 + Spring Demo application: World Cup Rusia 2018 stats

Tue, 03 Jul 2018 16:36:00 +0000

To test out some new interesting web technologies, we decided to go ahead and build a small demo application that will point out ideas that could potentially help a developer when trying to decide which ones to use in a new project. We decided to create a small application with responsiveness in mind, that would show real time and aggregated data about the current Football World Cup event that is taking place in Russia.

Technologies

The chosen technologies where:

Vaadin 10: The brand new version of the popular framework, that is powered by the new standards being pushed by the most popular browsers.
SpringFramework: The almost de-facto standard dependency injection framework, that stands as the backbone of almost every java project that are currently being built.
REST API: Our project uses the API available here. That API exposes data as a REST API with information being delivered in JSON format.

Features

This is a short list of currently supported features:

The application is responsive, it will correctly display information regardless the device being used. This feature is achieved by using Vaadin & Polymer technologies.
Depending on the device that you’re browsing the site (especially mobile phones), you can add the application to the home screen, so it will look like a native application. The only catch is that it will not function in offline mode (yet, maybe sooner).
You can follow the matches in realtime. Using WebSockets, the application maintains an opened communication pipe between the browser and the server, so the updates can be informed to the client as soon as they are received from the API

Construction

You need to have a good starting point to start any new project. For us it was the Vaadin Base Project with String starter. By choosing this option, we could benefit of the fact that it already has a tested and working Spring configuration, so it was an easy decision.

Responsiveness

We achieved this goal, by starting also a parallel development: a new Addon for the Vaadin platform that helps you to build new applications using a simple skeleton that takes care of building the usual visual elements present in a responsive application: hamburger menu, paper-cards and more.

Besides that, we also used some CSS techniques as media queries to make the final touches.

PWA

To allow the application to be added to the home screen of your device, and then showing it as a native application, we generated a PWA manifest, with some properties that you can easily mimic, by using a tool like the App Manifest Generator.

Realtime updates

This feature is really easy to implement, given Vaadin’s @Push tecnology, based on websockets. Just adding a simple annotation to your main layout will give life to your bubbling screen.

You can learn more about this technology in Vaadin’s official documentation.

Roadmap

These are the things we would like to implement in the near future:

ComboBox lazy loading with REST API in Vaadin 8

Mon, 09 Apr 2018 13:55:00 +0000

In this post we’ll explore how to access a REST service in order to display items in a ComboBox in Vaadin 8.

First, we’ll implement a REST service with Spring Boot, as described here

The web service will be exposed at http://127.0.0.1:8081/api/countries. It will receive no parameters and return an array containing the name of all the countries known by the JVM (the Geography knowledge of the JVM is amazing!).

@RestController
public class CountriesController {
@RequestMapping("/api/countries")
public String[] getCountries() {
 return countries().toArray(String[]::new);
} 

private static Stream&lt;String&gt; getCountries() {
 return Stream.of(Locale.getISOCountries())
 .map(countryCode -&gt; new Locale("", countryCode))
 .map(locale-&gt;locale.getDisplayCountry(Locale.ENGLISH))
 .sorted();
}

}

Our first year in review

Sun, 01 Apr 2018 15:00:00 +0000

Today we are celebrating the first birthday of our startup. It’s been a long year filled with a lot of experiences and we want to review some of them:

After we started to exist, we also started to grow, new developers joined our team, and accepted new challenges.

We completed all the necessary steps for becoming a full blown company according the laws of our country.

After searching a lot, we found our place in the world, and, of course, we celebrated this achievement!

We wrote a lot of technical notes, as a way of sharing the result of our knowledge and experience with the community. We created an organization in GitHub and then started to contribute with some interesting projects. We also created some social media accounts to share articles, opinions and nice pictures of our #FlowingCodeLife with the community.

Because we think that is never too late to incorporate new knowledge, we started a new internal program called Learning Fridays were we acquire concepts regarding the following subjects:

First experience writing a Vaadin 10 Addon
Bower, WebJars and Vaadin 10
Spring Reactive
Domain Driven Architectures
Modern Web Layout with Flexbox and CSS Grid
Vaadin’s Flow
Vaadin’s Drag & Drop
JavaScript Objects and Prototypes
Progressive Web Apps
Scaling Java Applications Through Concurrency
Machine Learning
Refactoring to a System of Systems (Micro services)
TensorFlow
Microservices with Spring Boot
Clean Architecture: Patterns, Practices, and Principles

Finally, we completely defined the internal benefits program of the company and started a recruiting process to make our team bigger.

Vaadin Widgetset compiling: Tips & Hints

Fri, 09 Feb 2018 19:36:00 +0000

Hi everyone!

The purpose of this post is enumerating the most common issues when trying to compile the widgetset in Vaadin. But before digging into this, let’s explain a little bit what this compiling thing is about.

In Vaadin version 6, 7 & 8, the visual components have two important parts.

The first one is server side, and it’s implemented in classic Java classes that are compiled to JVM bytecode.

The second part, on the other hand, is the client side code, written mostly in Java and then compiled in Javascript using GWT project. GWT is basically a Java to Javascript compiler. All of these components (widgets) belong to a set known as widgetset.

The widgetset compilation process is done by executing the GWT compiler to produce the Javascript code associated to all of the Vaadin components that have server and client side code.

That being said, let’s go on with those tips!

Verify that everything is correctly configured

There are a lot of ways to compile the widgetset, in this case we will focus in projects that use maven as the build tool, because is the most commonly tool used for this purpose.

The vaadin-maven-plugin will help you on this process, which is a derivation of the gwt-maven-plugin.

Depending on the Vaadin version used, there a are a lot of different configurations, the best thing to do, is to create a small maven project, based on the simplest vaadin maven archetype (com.vaadin:vaadin-archetype-application)

These are the steps for doing this:

Run the command “mvn archetype:generate” from a terminal or command line window
Enter “vaadin” to filter the list of the available archetypes
Choose 5 (currently that’s the number of the com.vaadin:vaadin-archetype-application archetype, it could change in the future)
Choose the number before the Vaadin version that you’re using (ie: 127 -> 7.7.13, etc.)
Complete the parameters that maven will prompt

After that, maven will generate a small project, and if you take a look to the pom.xml file that was generated, you are going to find something like this:

Debugging GWT client side code in Vaadin with Eclipse

Tue, 12 Dec 2017 14:17:00 +0000

You know, if you’re developing a Vaadin application, it is not necessary to understand how to code client side using GWT, unless you’re building your own custom component, and you need to add some special client-side code. In that case, you are going to realize that whenever you want to test your component, debugging it can be tricky.

The problem is that client side code is not executed by the JVM, instead that code is going to be executed by the browser, and because of this all of the debugging facilities provided by the Java platform are useless.

Let me tell you what you need to take into account for being able to successfully debug your code.

1 – Modify your .gwt.xml file

The first thing you need to do is to modify the file that contains all of your widgetset information, by adding this line inside the tag <module/>:

Main HQ Inauguration & Vaadin talks

Tue, 28 Nov 2017 18:28:00 +0000

Last Tuesday we organized a little event, that targeted two primary objectives: Let the developers of the surrounding area know us and our installations, and kickstart our planned set of technology speeches, targeted for next year.
We offered a couple of presentations, the first one was related to Vaadin 8, where we gave an overview of the framework, the architecture, and a list of the best new features since Vaadin 7.
Then we presented the new Vaadin 10 platform, explaining the new technologies behind the framework, and the new features available in the developer preview.
After that, we invited everyone to taste some snacks and drinks in the open balcony with a starry sky as a background, talking about new technologies and making some good networking.
Here we share some photos of the event!

Implementing Spring Security on a Vaadin application

Mon, 30 Oct 2017 15:35:00 +0000

Today I’m going to write a little bit about my experience of trying to secure a simple Vaadin application using one of the most popular security frameworks: the security extensions of SpringFramework.
This post will cover the part of configuring a default setting to make it work, of course after this, there are a lot of things to do in your project to finish implementing this, such as storing and retrieving your user details from the underlying datastore of your choice, choosing the password-hashing algorithm, and so on. But at least you will have an overview of what needs to be done to accomplish this.

Vaadin’s Grid editing capabilities

Mon, 30 Oct 2017 14:15:00 +0000

This time I’d like to talk a little bit about something that I believe is one of the most powerful capabilities of Vaadin Grid component: the editing feature. The default view of the component is a read-only view, of the tabular data loaded in the component. But if you enable the editor, you can visually edit the grid’s cells and change the data that the grid is holding in the server’s memory. Let’s dig in some difficulties to use this feature and how to overcome them.

Inline editing

If you look at the demo sampler application, you’ll see that the Item Editor, is like a little form that opens whenever you double click a row. That’s different than the previous component in older Vaadin versions (Table). With Table, when you double click on it, the entire row turn into read/write mode, without changing the row into a “mini form” as grid does now. Of course this behavior is configurable, you can disable it just by calling setBuffered(false).

Despite of being somehow more visual, this new conduct, could be an undesirable behavior for enterprise applications that happens to use the keyboard a lot, and not depending so much on the mouse, to handle the table or grid.

If your users desire that kind of grid management, then the Grid Fast Navigation Addon is for you. It uses the Component Extension feature, to give the grid a new look, that makes the editing much more easier, and transforms it in a sort of excel style facility.

Grid Fast Navigation Addon in action

Components

Another thing that prevented some developers to stop using Table and starting to use grid, was that you couldn’t use a standard component inside a cell of a Grid. If you wanted to, for example, use checkboxes inside a cell, you had to create a special class, called “renderer”, that should handle the server and the client side of that cell.

Luckily there are some addons that may help you with that task. The one that stands out is the Grid renderes collection (it exists for Vaadin 7 and 8 versions). It provides a lot of components that let you handle select, checkbox, images, etc.

In the last version of Vaadin, one of the most interesting features, is a new Renderer, that adds the capability to render a Vaadin component inside a cell of a grid. You can see a preview in the sampler application.

If you are using Vaadin 7, although, you could use a experimental version of that feature, installing the Component Renderer Addon.
Happy coding!