I'm Java backend engineer and would like to start the brand-new project. Unfortunately for me working with UI is some kind of nightmare :) This is why I'm looking for some framework which will abstract me from the low level JavaScript details and the best choice for now looks like is Vaadin Flow (pure Java).
Right now, I'm trying to select - what is the right version of Vaadin to start the project with - Vaadin 14 or recently released Vaadin 20? Please advise. Is it the right time to start with Vaadin 20?
It depends when you want to go to production with your application.
You can checkout the Vaadin roadmap to see when the releases are planned:
https://vaadin.com/roadmap
Upcoming releases
Vaadin 14.7 LTS*, release date announced later
Vaadin 21, estimated release September 2021
Vaadin 22, estimated release December 2021
Vaadin 23 LTS*, estimated release March 2022
If you want to go live next year I would go with Vaadin 20 otherwise with Vaadin 14.
In one project we are on Vaadin 20 already because the DataProvider changed in 19 and you don't need a CountCallback what is very handy if you want to use Grids with data from a REST API where you never have a count endpoint.
Related
We have a 5 year old application written in vaadin 6. It only uses basic vaadin UI framework functions. If we want to upgrade to a newer vaadin version that will be supported, what is the version we should go to? I understand that moving from v6 to v7 and above requires some rework. Is vaadin 8 the best version to use to complete this UI migration? How long will vaadin 8 be supported? Are the UI framework stable after vaadin 8, i.e. upgrading to higher versions do not require changes in the application? Thanks for some guidance.
Vaadin versions are either incremental or come with long-term support.
A long-term support version is maintained as an open source product for 5 years after the initial release. Additionally, Vaadin is offering commercial support for another 10 years. An incremental version is only maintained for a short overlap after the next version.
Vaadin 7 is already more than 5 years old and thus only supported based on commercial contracts. Commercial support is available until 2029.
Open support for Vaadin 8 ends in February 2022, while commercial support is available until 2032.
Vaadin 10 is still supported, but there are aren't any good reasons to choose it over Vaadin 14 at this time.
Vaadin 14 has free support until 2024 and commercial support until 2034. This is the version generally recommended for new projects today.
Vaadin 23 is planned (but not absolutely certain) to be released in the beginning of 2022 with long-term support until 2027. It might be an alternative for new projects to go with incremental versions until that.
The other side of the coin is how easy it is to update your existing project. Vaadin 7 and Vaadin 8 is roughly the same from that point of view since Vaadin 8 also includes an extensive compatibility package that covers basically everything from Vaadin 7.
The jump to from Vaadin 6 to either Vaadin 14 or Vaadin 23 is bigger than the jump to Vaadin 8, but there isn't a big difference between 14 and 23 when it comes to the work needed for migrating from 6.
I'm new to Angular and I'm a bit confused whether the implementation of the angular components reflects the recent (2018) material design system changes or they are just updating the old version of the system?
the Angular components version is been updated:
https://trimox.github.io/angular-mdc-web/#/angular-mdc-web/home
But it seems to me that the Angular Dart components version is still using the old system:
https://dart-lang.github.io/angular_components/
Am I missing something or the Angular components will not get the latest material design updates?
(I think the Angular team is using foundations and adapters to adapt the vanilla web version of the updated material design system, is the Angular Dart team doing the same?)
The specs and M2 components are still being worked on. We have some ready, but I don't see us releasing them until after internal teams have shaken out most of the bugs. They are still going through big API changes to make sure they work well in our products.
There is one that is released which is the material_card.
I just installed VS 2017 and am opening an MVC 5 project created in VS 2015. The application runs fine, but I am experiencing reduced interactivity between my MVC Razor view code and the 2017 IDE.
Here's is the context menu when I right-click on an HTML helper method in VS 2015:
However, I only see this in 2017:
Also notice the lack of syntax color-coding in the 2017 verison. It's like it's not recognizing Razor syntax at all.
I did not do any special solution/project upgrades. I just opened the solution in 2017 and expected it to prompt me to upgrade any files that needed upgrading.
So it turns out that the component installation for VS 2017 is modular in that you have to install exactly what you need. This is different from 2015 (at least as far as I recall) where all components are included with the installation.
I have a tendency not to read entire pages and just focus on what seems like the "most comprehensive" option. In my case, I selected only Universal Windows Platform development (doesn't that just sound like everything you'd need?). If I bothered to look at all the components, I would have seen ASP.NET and web development.
So, after modifying my installation, I am now seeing all the Razor syntax in my views.
Repair your Visual Studio installation. This happened to me as well.
Go to Tools Options and customize menus and ribbons
also have a look: https://msdn.microsoft.com/en-us/library/wdee4yb6.aspx
and or: https://msdn.microsoft.com/en-us/library/wdee4yb6(v=vs.110).aspx
try reset the existing window layout or menus and options.
or repair your VS
I looked at many examples of Vaadin and all of them use Vaadin servlet. Is it possible to use Vaadin framework outside a servlet container? If yes, how to achieve that? A sample code would be most welcome.
Vaadin needs a Servlet Environment. Notice however that the Servlet Specification is just a tiny (but essential) part of Java EE. A Servlet Container is typically very light-weight.
So use Undertow, Jetty, Tomcat or any other Servlet Container. Note that these products are all embeddable, ideal for micro services.
Web Components
In recent years, the Vaadin company has been producing versions of their widgets that can run outside of their server-side Java framework. They are taking advantage of advancements being made in Web Components and the Google Polymer project.
The company has launched their Vaadin Elements program.
Vaadin Elements is a set of custom HTML elements tailored for business applications. It extends the Google Polymer library with elements like data grid, charts and combo box so you can build the app your business needs. The elements are actively maintained and tested to ensure compatibility with the latest Polymer releases.
For example, their excellent rows-and-columns Vaadin Grid component is available in three editions:
Vaadin FrameworkThe Vaadin server-side Java framework based on Java Servlet technology.
Vaadin GWT Polymer ElementsFor Google Web Toolkit developers.
Vaadin ElementsFor JavaScript developers.
Be forewarned: the Vaadin team is pushing the envelope in these new web technologies. But they are very excited by their successes and eagerly invite people to try out the new editions of their products.
See the Vaadin company blog for announcements of their success with various components in this effort.
Just yesterday (2016-04) they described a Date Picker widget and a file-uploader widget, both being available as betas in their Vaadin Elements collection.
The week before that they described a beta of a ComboBox widget for Polymer.
The week before that was an entry about their Vaadin Charts 3.0 product being finalized and shipping, both for the Vaadin Framework (server-side, Java) as well as for client-side developers using Polymer, AngularJS, React, or other HTML5 library.
For a very technical discussion, see the video and slides from a meeting at the Seattle Java Users Group (SeaJUG) in 2016-03 in a presentation by Vaadin staffer, Marcus Hellberg.
I have been some time away from Dart. What happened to AngularDart and PolymerDart?
What is the way to go 2015?
Angular has released 1.0 but left it quite unmainained and development now focuses on Angular 2.0 which is written in AtScript and transpiled to Dart and JS. An early alpha of Angular 2.0 for Dart is available at pub.dartlang.org.
Polymer has evolved slowly the recent year. Most effort went into core- and paper-elements. Recently Polymer 0.8 (current 0.5.x) was announced and will bring some breaking changes. The architecture is changed to allow to choose between different levels of support (and with it the library size you add to your app) and some breaking changes how attributes and properties are defined and used.
A Polymer.js 0.8 release is expected during this month, availability for Dart will take a few weeks longer I guess.