|This migration documentation has been revised for Vaadin 14.2 release. It is recommended to migrate to Vaadin 14 since it is the latest LTS and has more features available than versions 10-13. Vaadin 14 also gets new minor releases, which are backward compatible, but add new features.|
Vaadin 14 belongs to the same continuum with Vaadin 8, even if the implementation details have changed a lot. The core concepts, architecture, and programming model remain largely the same, but the new technology tree based on modern Web Components provides a lot of new and exciting possibilities as well:
On the server-side, where many Java developers feel most at home, a lot remains the same. The client-side has been completely rehauled with the move away from GWT, however, and the new implementation ensures that the client-side of the familiar and new Vaadin components can now be reused with any modern web framework. Even better, this interchangeability also means that you can easily add Web Components from other frameworks into your Vaadin application! This gives you an even greater toolset for building reusable UI components.
The bridge between the Java server-side and the new client-side is called Vaadin Flow. It helps to make the server-side developer experience largely the same as before. If you are happy with the old server-side features, there is no need to look further - you can still do most of the same things without ever stepping away from the Java side. But if you do want to expand your application with the new client-side capabilities, Vaadin Flow helps you to connect the new features to the server-side.
It is good to keep in mind that the feature set is not completely identical between Vaadin 8 and Vaadin 14. Because everything needed to be rewritten for the new client-side some features have been removed (at least temporarily, we are adding old features back all the time!), although there are a lot of great new additions as well. This discrepancy can bring some challenges to the migration process, depending on the feature set in use. Make sure to choose the migration strategy that best suits your needs.
There are different migration strategies for Vaadin 8 applications:
Staying with Vaadin 8 - it is great! And supported at least until 2022.
Transforming an existing Vaadin 8 application into a Vaadin 14 application.
Fresh start by redesigning an existing Vaadin 8 application using Vaadin 14 tools.
Using the Multiplatform Runtime (available through Prime or Enterprise subscription) to run views or components from a Vaadin 8 application inside your Vaadin 14 application. There are at least three alternative use cases for this approach:
Migrating the application bit by bit
Extending the application with new parts implemented with Vaadin 14
Continued support of a dropped feature that hasn’t been added back to Vaadin 14 yet
Vaadin 14 is the latest LTS version and it is recommended to use that instead of versions 10-13. The migration strategies are described in more detail in the next chapter.
The easiest and fastest way to understand what migrating to Vaadin 14 means to you is to use our migration assessment service. Our experts will go through your application to determine the most suitable migration strategy and how much effort the migration is likely to require.
Most of the migration documentation covers the features that have changed or been removed between Vaadin 8 and Vaadin 14. But not everything has changed and at the core it is still the same product. The following concepts are not covered, since they have stayed the same between the versions:
Possibility to use Java and high-level APIs to compose UIs on the server side with ready-made components
Stateful server-side architecture
Automated client-server communication using request-response, server push, or polling
Data Binding API with
Minimum server requirements: Java 8 and Servlet 3.0
Minimum browsers supported: Internet Explorer 11 and evergreen browsers
For the most part the developer experience of building UIs is still the same. You have access to a similar set of ready-made components and a similar high-level and type-safe Java API. In particular, the API for binding data to components, which is a major part of any application, remains largely the same as in Vaadin 8. All the components have been redesigned to provide better end user experience, and we add new components (or new implementations of old components) to the list frequently. Creating your own components is also a lot easier than before.
Check out the following pages for some notable differences between Vaadin 8 and Vaadin 14: