Home Web-development Learning Vaadin 7: Second Edition
Learning Vaadin 7: Second Edition
By Nicolas Fränkel
Vaadin and its Context
Rich applications
Why Vaadin?
Environment Setup
Vaadin in Eclipse
Vaadin in IntelliJ IDEA
Vaadin and other IDEs
Hello Vaadin!
Understanding Vaadin
Deploying a Vaadin application
Using Vaadin applications
Behind the surface
Components and Layouts
Thinking in components
Laying out the components
Bringing it all together
Event Listener Model
Event-driven model
Event model in Vaadin
Containers and Related Components
Data in Vaadin
Refining Twaattin
Core Advanced Features
Accessing the JavaEE API
Navigation API
Embedding Vaadin
Real-world error handling
SQL container
Server push
Twaattin improves!
Vaadin add-ons directory
Noteworthy add-ons
Creating and Extending Components and Widgets
Client-side extensions
Shared state
Server RPC
GWT widget wrapping
JavaScript wrapping
Componentized Twaattin
Vaadin is a new Java web framework for making applications look great and perform well, making your users happy. Vaadin promises to make your user interfaces attractive and usable while easing your development efforts and boosting your productivity as a developer. Vaadin is a web framework that addresses common issues such as poor choice of controls, heterogeneity of technology stacks, page-flow paradigm, and browser compatibility.
This book a practical guide that will help you in creating top-notch web applications with one of the best frameworks based on Java. You will learn about the fundamental concepts that are the cornerstones of the framework. Also, this book will show you how to integrate Vaadin with popular frameworks and how to run it on top of internal as well as externalized infrastructures.
Learning Vaadin: Second Edition is a practical, step-by-step tutorial to understanding, using, and mastering the art of RIA development with Vaadin. You will learn about the fundamental concepts that are the cornerstones of the framework, at the same time as making progress on building your own web application. The book will also show you how to integrate Vaadin with other popular frameworks and how to run it on top of internal as well as externalized infrastructures.
This book will show you how to become a professional Vaadin developer by giving you a concrete foundation through diagrams, practical examples, and ready-to-use source code. It will enable you to grasp all the notions behind Vaadin one step at a time: components, layouts, events, containers, and bindings. You will learn to build first-class web applications using best-of-breed technologies. You will find detailed information on how to integrate Vaadin's presentation layer on top of other widespread technologies, such as Spring, CDI, and Hibernate. Finally, the book will show you how to deploy on different infrastructures like JBoss Portal and Cloud Foundry.
With this book in hand you will be able to utilize the full range of development and deployment features offered by Vaadin while thoroughly understanding the concepts.
Chapter 1. Vaadin and its Context
Developing Java applications and more specifically, developing Java web applications should be fun. Instead, most projects are a mess of sweat and toil, pressure and delays, costs and cost cutting. Web development has lost its appeal. Yet, among the many frameworks available, there is one in particular that draws our attention because of its ease of use and its original stance. It has been around since the past decade and has begun to grow in importance. The name of this framework is Vaadin. The goal of this book is to see, step-by-step, how to develop web applications with Vaadin.
Vaadin is the Finnish word for a female reindeer (as well as a Finnish goddess). This piece of information will do marvels to your social life as you are now one of the few people on Earth who know this (outside Finland).
We are going to see Vaadin in detail in later chapters; the following is a preview of what it is:
A component-based approach that really works, and provides a bunch of out-of-the-box components as well as extensions
Full web compatibility, in addition to Google Web Toolkit
All development is made completely in Java
Most of the code can be run server-side, taking advantages of Java static typing, with the full power of dynamic update tools such as JRebel
Integration with Eclipse and IntelliJ IDEA IDEs
Available with no charge under a friendly Open Source Apache license and much, much more
Before diving right into Vaadin, it is important to understand what led to its creation. Readers who already have this information (or who don't care) should go directly to Chapter 2, Environment Setup.
In this chapter, we will look into the following:
The evolution from mainframe toward the rich client.
The concept of application tier
The many limits of the thin-client approach
What stands beyond those limits
Why choose Vaadin today?
The state of the market
Vaadin's place in the market
A preview of what other frameworks Vaadin can be integrated with and what platforms it can run on
Vaadin is often referred to as a Rich Internet Application (RIA) framework. Before explaining why, we need to first define some terms which will help us describe the framework. In particular, we will have a look at application tiers, the different kind of clients, and their history.
Application tiers
Some software run locally, that is, on the client machine and some run remotely, such as on a server machine. Some applications also run on both the client and the server. For example, when requesting an article from a website, we interact with a browser on the client side but the order itself is passed on a server in the form of a request.
Traditionally, all applications can be logically separated into tiers, each having different responsibilities as follows:
Presentation: The presentation tier is responsible for displaying the end-user information and interaction. It is the realm of the user interface.
Business Logic: The logic tier is responsible for controlling the application logic and functionality. It is also known as the application tier, or the middle tier as it is the glue between the other two surrounding tiers, thus leading to the term middleware.
Data: The data tier is responsible for storing and retrieving data. This backend may be a file system. In most cases, it is a database, whether relational, flat, or even an object-oriented one.
This categorization not only naturally corresponds to specialized features, but also allows you to physically separate your system into different parts, so that you can change a tier with reduced impact on adjacent tiers and no impact on non-adjacent tiers.
Tier migration
In the history of computers and computer software, these three tiers have moved back and forth between the server and the client.
When computers were mainframes, all tiers were handled by the server. Mainframes stored data, processed it, and were also responsible for the layout of the presentation. Clients were dumb terminals, suited only for displaying characters on the screen and accepting the user input.
Not many companies could afford the acquisition of a mainframe (and many still cannot). Yet, those same companies could not do without computers at all, because the growing complexity of business processes needed automation. This development in personal computers led to a decrease in their cost. With the need to share data between them, the network traffic rose.
This period in history saw the rise of the personal computer, as well as the Client server term, as there was now a true client. The presentation and logic tier moved locally, while shared databases were remotely accessible, as shown in the following diagram:
Big companies migrating from mainframes to client-server architectures thought that deploying software on ten client machines on the same site was relatively easy and could be done in a few hours. However, they quickly became aware of the fact that with the number of machines growing in a multi-site business, it could quickly become a nightmare.
Enterprises also found that it was not only the development phase that had to be managed like a project, but also the installation phase. When upgrading either the client or the server, you most likely found that the installation time was high, which in turn led to downtime and that led to additional business costs.
Around 1991, Sir Tim Berners-Lee invented the Hyper Text Markup Language, better known as HTML. Some time after that, people changed its original use, which was to navigate between documents, to make HTML-based web applications. This solved the deployment problem as the logic tier was run on a single-server node (or a cluster), and each client connected to this server. A deployment could be done in a matter of minutes, at worst overnight, which was a huge improvement. The presentation layer was still hosted on the client, with the browser responsible for displaying the user interface and handling user interaction.
This new approach brought new terms, which are as follows:
The old client-server architecture was now referred to as fat client.
The new architecture was coined as thin client, as shown in the following diagram:
Limitations of the thin-client applications approach
Unfortunately, this evolution was made for financial reasons and did not take into account some very important drawbacks of the thin client.
Poor choice of controls
HTML does not support many controls, and what is available is not on par with fat-client technologies. Consider, for example, the list box: in any fat client, choices displayed to the user can be filtered according to what is typed in the control. In legacy HTML, there's no such feature and all lines are displayed in all cases. Even with HTML5, which is supposed to add this feature, it is sadly not implemented in all browsers. This is a usability disaster if you need to display the list of countries (more than 200 entries!). As such, ergonomics of true thin clients have nothing to do with their fat-client ancestors.
Many unrelated technologies
Developers of fat-client applications have to learn only two languages: SQL and the technology's language, such as Visual Basic, Java, and so on.
Web developers, on the contrary, have to learn an entire stack of technologies, both on the client side and on the server side.
On the client side, the following are the requirements:
First, of course, is HTML. It is the basis of all web applications, and although some do not consider it a programming language per se, every web developer must learn it so that they can create content to be displayed by browsers.
In order to apply some common styling to your application, one will probably have to learn the Cascading Style Sheets (CSS) technology. CSS is available in three main versions, each version being more or less supported by browser version combinations (see Browser compatibility).
Most of the time, it is nice to have some interactivity on the client side, like pop-up windows or others. In this case, we will need a scripting technology such as ECMAScript.
ECMAScript is the specification of which JavaScript is an implementation (along with ActionScript). It is standardized by the ECMA organization. See http://www.ecma-international.org/publications/standards/Ecma-262.htm for more information on the subject.
Finally, one will probably need to update the structure of the HTML page, a healthy dose of knowledge of the Document Object Model (DOM) is necessary.
As a side note, consider that HTML, CSS, and DOM are W3C specifications while ECMAScript is an ECMA standard.
From a Java point-of-view and on the server side, the following are the requirements:
As servlets are the most common form of request-response user interactions in Java EE, every web developer worth his salt has to know both the Servlet specification and the Servlet API.
Moreover, most web applications tend to enforce the Model-View-Controller paradigm. As such, the Java EE specification enforces the use of servlets for controllers and JavaServer Pages (JSP) for views. As JSP are intended to be templates, developers who create JSP have an additional syntax to learn, even though they offer the same features as servlets.
JSP accept scriptlets, that is, Java code snippets, but good coding practices tend to frown upon this, however, as Java code can contain any feature, including some that should not be part of views—for example, the database access code. Therefore, a completely new technology stack is proposed in order to limit code included in JSP: the tag libraries. These tag libraries also have a specification and API, and that is another stack to learn.
However, these are a few of the standard requirements that you should know in order to develop web applications in Java. Most of the time, in order to boost developer productivity, one has to use frameworks. These frameworks are available in most of the previously cited technologies. Some of them are supported by Oracle, such as Java Server Faces, others are open source, such as Struts.
JavaEE 6 seems to favor replacement of JSP and Servlet by Java Server Faces (JSF). Although JSF aims to provide a component-based MVC framework, it is plagued by a relative complexity regarding its components lifecycle.
Having to know so much has negative effects, a few are as follows:
On the technical side, as web developers have to manage so many different technologies, web development is more complex than fat-client development, potentially leading to more bugs
On the human resources side, different meant either different profiles were required or more resources, either way it added to the complexity of human resource management
On the project management side, increased complexity caused lengthier projects: developing a web application was potentially taking longer than developing a fat-client application
All of these factors tend to make the thin-client development cost much more than fat-client, albeit the deployment cost was close to zero.
The Web has standards, most of them upheld by the World Wide Web Consortium. Browsers more or less implement these standards, depending on the vendor and the version. The ACID test, in version 3, is a test for browser compatibility with web standards. Fortunately, most browsers pass the test with 100 percent success, which was not the case two years ago.
Some browsers even make the standards evolve, such as Microsoft which implemented the XmlHttpRequest object in Internet Explorer and thus formed the basis for Ajax.
One should be aware of the combination of the platform, browser, and version. As some browsers cannot be installed with different versions on the same platform, testing can quickly become a mess (which can fortunately be mitigated with virtual machines and custom tools like http://browsershots.org). Applications should be developed with browser combinations in mind, and then tested on it, in order to ensure application compatibility.
For intranet applications, the number of supported browsers is normally limited. For Internet applications, however, most common combinations must be supported in order to increase availability. If this wasn't enough, then the same browser in the same version may run differently on different operating systems.
In all cases, each combination has an exponential impact on the application's complexity, and therefore, on cost.
Page flow paradigm
Fat-client applications manage windows. Most of the time, there's a main window. Actions are mainly performed in this main window, even if sometimes managed windows or pop-up windows are used.
As web applications are browser-based and use HTML over HTTP, things are managed differently. In this case, the presentation unit is not the window but the page. This is a big difference that entails a performance problem: indeed, each time the user clicks on a submit button, the request is sent to the server, processed by it, and the HTML response is sent back to the client.
For example, when a client submits a complex registration form, the entire page is recreated on the server side and sent back to the browser even if there is a minor validation error, even though the required changes to the registration form would have been minimal.
Over the last few years, users have been applying some pressure in order to have user interfaces that offer the same richness as good old fat-client applications. IT managers, however, are unwilling to go back to the old deploy-as-a-project routine and its associated costs and complexity. They push towards the same deployment process as thin-client applications. It is no surprise that there are different solutions in order to solve this dilemma.
What are rich clients?
All the following solutions are globally called rich clients, even if the approach differs. They have something in common though: all of them want to retain the ease of deployment of the thin client and solve some or all of the problems mentioned previously.
Rich clients fulfill the fourth quadrant of the following schema, which is like a dream come true, as shown in the following diagram:
Some rich client approaches
The following solutions are strategies that deserve the rich client label.
Ajax was one of the first successful rich-client solutions. The term means Asynchronous JavaScript with XML. In effect, this browser technology enables sending asynchronous requests, meaning there is no need to reload the full page. Developers can provide client scripts implementing custom callbacks: those are executed when a response is sent from the server. Most of the time, such scripts use data provided in the response payload to dynamically update relevant part of the page DOM.
Ajax addresses the richness of controls and the page flow paradigm. Unfortunately:
It aggravates browser-compatibility problems as Ajax is not handled in the same way by all browsers.
It has problems unrelated directly to the technologies, which are as follows:
Either one learns all the necessary technologies to do Ajax on its own, that is, JavaScript, Document Object Model, and JSON/XML, to communicate with the server and write all common features such as error handling from scratch.
Alternatively, one uses an Ajax framework, and thus, one has to learn another technology stack.
Richness through a plugin
The oldest way to bring richness to the user's experience is to execute the code on the client side and more specifically, as a plugin in the browser. Sun—now Oracle—proposed the applet technology, whereas Microsoft proposed ActiveX . The latest technology using this strategy is Flash.
All three were failures due to technical problems, including performance lags, security holes, and plain-client incompatibility or just plain rejection by the market.
There is an interesting way to revive the applet with the Apache Pivot project, as shown in the following screenshot (http://pivot.apache.org/), but it hasn't made a huge impact yet;
A more recent and successful attempt at executing code on the client side through a plugin is through Adobe's Flex. A similar path was taken by Microsoft's Silverlight technology.
Flex is a technology where static views are described in XML and dynamic behavior in ActionScript. Both are transformed at compile time in Flash format.
Unfortunately, Apple refused to have anything to do with the Flash plugin on iOS platforms. This move, coupled with the growing rise of HTML5, resulted in Adobe donating Flex to the Apache foundation. Also, Microsoft officially renounced plugin technology and shifted Silverlight development to HTML5.
Deploying and updating fat-client from the web
The most direct way toward rich-client applications is to deploy (and update) a fat-client application from the web.
Java Web Start
Java Web Start (JWS), available at http://download.oracle.com/javase/1.5.0/docs/guide/javaws/, is a proprietary technology invented by Sun. It uses a deployment descriptor in Java Network Launching Protocol (JNLP) that takes the place of the manifest inside a JAR file and supplements it. For example, it describes the main class to launch the classpath, and also additional information such as the minimum Java version, icons to display on the user desktop, and so on.
This descriptor file is used by the javaws executable, which is bundled in the Java Runtime Environment. It is the javaws executable's responsibility to read the JNLP file and do the right thing according to it. In particular, when launched, javaws will download the updated JAR.
The detailed process goes something like the following:
The user clicks on a JNLP file.
The JNLP file is downloaded on the user machine, and interpreted by the local javaws application.
The file references JARs that javaws can download.
Once downloaded, JWS reassembles the different parts, create the classpath, and launch the main class described in the JNLP.
JWS correctly tackles all problems posed by the thin-client approach. Yet it never reaches critical mass for a number of reasons:
First time installations are time-consuming because typically lots of megabytes need to be transferred over the wire before the users can even start using the app. This is a mere annoyance for intranet applications, but a complete no go for Internet apps.
Some persistent bugs weren't fixed across major versions.
Finally, the lack of commercial commitment by Sun was the last straw.
A good example of a successful JWS application is JDiskReport (http://www.jgoodies.com/download/jdiskreport/jdiskreport.jnlp), a disk space analysis tool by Karsten Lentzsch, which is available on the Web for free.
Update sites
Updating software through update sites is a path taken by both Integrated Development Environment (IDE) leaders, NetBeans and Eclipse. In short, once the software is initially installed, updates and new features can be downloaded from the application itself.
Both IDEs also propose an API to build applications.
This approach also handles all problems posed by the thin-client approach. However, like JWS, there's no strong trend to build applications based on these IDEs. This can probably be attributed to both IDEs using the OSGI standard whose goal is to address some of Java's shortcomings but at the price of complexity.
Google Web Toolkit (GWT) is the framework used by Google to create some of its own applications. Its point of view is very unique among the technologies presented here. It lets you develop in Java, and then the GWT compiler transforms your code to JavaScript, which in turn manipulates the DOM tree to update HTML. It's GWT's responsibility to handle browser compatibility. This approach also solves the other problems of the pure thin-client approach.
Yet, GWT does not shield developers from all the dirty details. In particular, the developer still has to write part of the code handling server-client communication and he has to take care of the segregation between Java server-code which will be compiled into byte code and Java client-code which will be compiled into JavaScript. Also, note that the compilation process may be slow, even though there are a number of optimization features available during development. Finally, developers need a good understanding of the DOM, as well as the JavaScript/DOM event model.
Vaadin is a solution evolved from a decade of problem-solving approach, provided by a Finnish company named Vaadin Ltd, formerly IT Mill.
Therefore, having so many solutions available, could question the use of Vaadin instead of Flex or GWT? Let's first have a look at the state of the market for web application frameworks in Java, then detail what makes Vaadin so unique in this market.
Despite all the cons of the thin-client approach, an important share of applications developed today uses this paradigm, most of the time with a touch of Ajax augmentation.
Unfortunately, there is no clear leader for web applications. Some reasons include the following:
Most developers know how to develop plain old web applications, with enough Ajax added in order to make them usable by users.
GWT, although new and original, is still complex and needs seasoned developers in order to be effective.
From a Technical Lead or an IT Manager's point of view, this is a very fragmented market where it is hard to choose a solution that will meet users' requirements, as well as offering guarantees to be maintained in the years to come.
Importance of Vaadin
Vaadin is a unique framework in the current ecosystem; its differentiating features include the following:
There is no need to learn different technology stacks, as the coding is solely in Java. The only thing to know beside Java is Vaadin's own API, which is easy to learn. This means:
The UI code is fully object-oriented
There's no spaghetti JavaScript to maintain
It is executed on the server side
Furthermore, the IDE's full power is in our hands with refactoring and code completion.
No plugin to install on the client's browser, ensuring all users that browse our application will be able to use it as-is.
As Vaadin uses GWT under the hood, it supports all browsers that the version of GWT also supports. Therefore, we can develop a Vaadin application without paying attention to the browsers and let GWT handle the differences. Our users will interact with our application in the same way, whether they use an outdated version (such as Firefox 3.5), or a niche browser (like Opera).
Moreover, Vaadin uses an abstraction over GWT so that the API is easier to use for developers. Also, note that Vaadin Ltd (the company) is part of GWT steering committee, which is a good sign for the future.
Finally, Vaadin conforms to standards such as HTML and CSS, making the technology future proof. For example, many applications created with Vaadin run seamlessly on mobile devices although they were not initially designed to do so.
Vaadin integration
In today's environment, integration features of a framework are very important, as normally every enterprise has rules about which framework is to be used in some context. Vaadin is about the presentation layer and runs on any servlet container capable environment.
Integrated frameworks
A whole chapter (see Chapter 9, Creating and Extending Components and Widgets) is dedicated to the details of how Vaadin can be integrated with some third-party frameworks and tools. There are three integration levels possible which are as follows:
Level 1: out-of-the-box or available through an add-on, no effort required save reading the documentation
Level 2: more or less documented
Level 3: possible with effort
The following are examples of such frameworks and tools with their respective integration estimated effort:
Java Persistence API (JPA): JPA is the Java EE 5 standard for all things related to persistence. An add-on exists that lets us wire existing components to a JPA backend. Other persistence add-ons are available in the Vaadin directory, such as a container for Hibernate, one of the leading persistence frameworks available in the Java ecosystem.
A bunch of widget add-ons, such as tree tables, popup buttons, contextual menus, and many more.
Spring is a framework which is based on Inversion of Control (IoC) that is the de facto standard for Dependency Injection. Spring can easily be integrated with Vaadin, and different strategies are available for this.
Context Dependency Injection (CDI): CDI is an attempt at making IoC a standard on the Java EE platform. Whatever can be done with Spring can be done with CDI. Given that CDI is a standard, we will have a look of its integration with Vaadin in Chapter 8, Featured Add-ons.
Any GWT extensions such as Ext-GWT or Smart GWT can easily be integrated in Vaadin, as Vaadin is built upon GWT's own widgets. This will be seen in complete detail in Chapter 9, Creating and Extending Components and Widgets, where we will create such new components.
We can use another entirely new framework and languages and integrate them with Vaadin, as long as they run on the JVM: Apache iBatis, MongoDB, OSGi, Groovy, Scala, anything you can dream of!
Integration platforms
Vaadin provides an out-of-the-box integration with an important third-party platform: Liferay is an open source enterprise portal backed by Liferay Inc. Vaadin provides a specialized portlet that enables us to develop Vaadin applications as portlets that can be run on Liferay. Also, there is a widgetset management portlet provided by Vaadin, which deploys nicely into Liferay's Control Panel.
Using Vaadin in the real world
If you embrace Vaadin, then chances are that you will want to go beyond toying with the Vaadin framework and develop real-world applications.
Concerns about using a new technology
Although it is okay to use the latest technology for a personal or academic project, projects that have business objectives should just run and not be riddled with problems from third-party products. In particular, most managers may be wary when confronted by a new product (or even a new version), and developers should be too.
The following are some of the reasons to choose Vaadin:
Product is of highest quality: The Vaadin team has done rigorous testing throughout their automated build process. Currently, it consists of more than 8,000 unit tests. Moreover, in order to guarantee full compatibility between versions, many (many!) tests execute pixel-level regression testing.
Commercial: Although completely committed to open source, Vaadin Limited offer commercial support for their product. Check their Pro Account offering.
User forums: A Vaadin user forum is available. Anyone registered can post questions and see them answered by a member of the team or of the community.
Note that Vaadin registration is free, as well as hassle-free: you will just be sent the newsletter once a month (and you can opt-out, of course).
Retro-compatibility:
API: The server-side API is very stable, version after version, and has survived major client-engines rewrite. Some part of the API has been changed from v6 to v7, but it is still very easy to migrate.
Architecture: Vaadin's architecture favors abstraction and is at the root of it all.
Full-blown documentation available:
Product documentation: Vaadin's site provides three levels of documentation regarding Vaadin: a five-minute tutorial, a one-hour tutorial, and the famed Book of Vaadin.
API documentation: The Javadocs are available online; there is no need to build the project locally.
Course/webinar offerings: Vaadin Ltd currently provides four different courses, which tackles all the needed skills for a developer to be proficient in the framework.
Huge community around the product: There is a community gathering, which is ever growing and actively using the product. There are plenty of blogs and articles online on Vaadin. Furthermore, there are already many enterprises using Vaadin for their applications.
Available competent resources: There are more and more people learning Vaadin. Moreover, if no developer is available, the framework can be learned in a few days.
Integration with existing product/platforms: Vaadin is built to be easily integrated with other products and platforms. The Book of Vaadin describes how to integrate with Liferay and Google App Engine.
Others already use Vaadin
Upon reading this, managers and developers alike should realize Vaadin is mature and is used on real-world applications around the world. If you still have any doubts, then you should check ://vaadin.com/who-is-using-vaadin and be assured that big businesses trusted Vaadin before you, and benefited from its advantages as well.
In this chapter, we saw the migration of application tiers in the software architecture between the client and the server.
We saw that each step resolved the problems in the previous architecture:
Client-server used the power of personal computers in order to decrease mainframe costs
Thin-clients resolved the deployment costs and delays
Thin-clients have numerous drawbacks. For the user, a lack of usability due to poor choice of controls, browser compatibility issues, and the navigation based on page flow; for the developer, many technologies to know.
As we are at the crossroad, there is no clear winner in all the solutions available: some only address a few of the problems, some aggravate them.
Vaadin is an original solution that tries to resolve many problems at once:
It provides rich controls
It uses GWT under the cover that addresses most browser compatibility issues
It has abstractions over the request response model, so that the model used is application-based and not page based
The developer only needs to know one programming language: Java, and Vaadin generates all HTML, JavaScript, and CSS code for you
Now we can go on and create our first Vaadin application!
Nicolas Fränkel
Nicolas Fränkel operates as a successful Java/Java EE architect with more than 10 years' experience in consulting for different clients. Based in France, he also practices (or has practiced) as a WebSphere Application Server administrator, a certified Valtech trainer, and a part-time lecturer in different French universities, so as to broaden his understanding of software craftsmanship. His interests in IT are diversified, ranging from Rich Client Application, to Quality Processes through open source software and build automation. When not tinkering with new products or writing blog posts, he may be found practicing sports: squash, kickboxing, and skiing at the moment. Other leisure activities include reading novels, motorcycles, photography, and drawing, not necessarily in that order.
Buono il contenuto del libro.
Well written book. It has all that I need from novice to experienced developer. The hands-on exercise are great and readable if you don't sit in front of a computer. Vaadin is great software and so it is even better to have a the book available to get you going at speed quickly.
12 May 2016 Ari
Excellent pour débuter avec Vaadin 7 lorsque l'on ne connait que peu de chose de ce framework.