Vaadin 8 has renewed the databinding functionality of Vaadin Framework. The Property, Item and Container have been taken out and AbstractField has been simplified to Binder. This presentation will tell all about the differences between framework versions 7 and 8.
Vaadin DevDay 2017 - Data Binding in Vaadin 8Peter Lehto
The document discusses improving editing of customer records in Vaadin 7 applications. It outlines issues with directly using setters and listeners on each field, such as lots of code, implicit saving, and difficulty validating values. It recommends using a FieldGroup to bind fields to properties, which avoids explicit setters, allows committing or discarding changes, and integrates validation into the commit process. However, it notes there may still be room for improvement over the Vaadin 7 approach.
What's new in Vaadin 8, how do you upgrade, and what's next?Marcus Hellberg
Presentation slides for the Vaadin 8 release meetup. Covers the new features in Vaadin 8 and 8.1, the migration steps from Vaadin 7 and what's up ahead for Vaadin.
Vaadin 8 with Spring Frameworks AutoConfigurationPeter Lehto
AutoConfiguration is an amazing feature of Spring Boot allowing integrating technologies more easily. Vaadin utilises AutoConfiguration for setting up beautiful Vaadin UIs with Spring Boot Applications. This talks tells all about how Boot's AutoConfiguration works with Vaadin and what kind of benefits it provides for developers
TDC2017 | São Paulo - Trilha Java EE How we figured out we had a SRE team at ...tdc-globalcode
This document discusses how to build APIs productively using Spring Boot, Spring MVC, and Spring Data. It covers how Spring Boot helps with dependency management, embedded servlet containers, and auto-configuration. Spring MVC is described as providing simplicity in API exposure and serialization/deserialization. Spring Data provides standard repository implementations and abstraction for data access across different data sources, including support for caching.
Data binding is a process that establishes a connection between an application's UI and its business logic so that when data changes, it is reflected in the UI and vice versa. Android introduced data binding in 2015 to minimize glue code between layouts and logic. The key steps to using data binding are: 1) adding the data binding library, 2) applying binding to layouts, 3) creating data binding objects, and 4) doing the binding in activities/fragments. Data binding supports observable objects to automatically update views when data changes. It allows binding layout properties like visibility and text fields.
The document discusses Magento's rendering system and how it generates output for the customer. The main goals of rendering are to generate headers and response body. It describes how controllers dispatch requests and set the response body. Layout, blocks and templates are loaded to generate the final HTML output. Key aspects covered include loading and building the layout, finding template files, and directly including templates to render block output.
Un moteur de recherche NoSQL pour chercher^H^H^H^H^H^H^H^H trouver...David Pilato
Vous cherchez toujours dans vos données avec des SELECT * FROM person WHERE name like '%david%pilato%" ?
Au delà des performances obtenues, êtes-vous certain de renvoyer les résultats les plus pertinents pour vos utilisateurs d'abord ?
Venez découvrir comment un moteur de recherche vous aidera à répondre aux questions posées par vos utilisateurs, de manière pertinente et efficace, tout en apportant des fonctionnalités d'analyse des résultats et ce, quelque soit le volume...
Would you like to make your Android UI code cleaner and more reactive? Android data binding can help. In this talk you’ll learn everything you need to know about data binding, including why it’s so powerful and how to use it effectively. If you haven’t tried data binding in the past, that’s okay! We’ll start with the basics, assuming no prior knowledge and slowly move into more advanced topics, such as 2-way binding, binding adapters, converters, best practices and common pitfalls to avoid.
Vaadin DevDay 2017 - Data Binding in Vaadin 8Peter Lehto
The document discusses improving editing of customer records in Vaadin 7 applications. It outlines issues with directly using setters and listeners on each field, such as lots of code, implicit saving, and difficulty validating values. It recommends using a FieldGroup to bind fields to properties, which avoids explicit setters, allows committing or discarding changes, and integrates validation into the commit process. However, it notes there may still be room for improvement over the Vaadin 7 approach.
What's new in Vaadin 8, how do you upgrade, and what's next?Marcus Hellberg
Presentation slides for the Vaadin 8 release meetup. Covers the new features in Vaadin 8 and 8.1, the migration steps from Vaadin 7 and what's up ahead for Vaadin.
Vaadin 8 with Spring Frameworks AutoConfigurationPeter Lehto
AutoConfiguration is an amazing feature of Spring Boot allowing integrating technologies more easily. Vaadin utilises AutoConfiguration for setting up beautiful Vaadin UIs with Spring Boot Applications. This talks tells all about how Boot's AutoConfiguration works with Vaadin and what kind of benefits it provides for developers
TDC2017 | São Paulo - Trilha Java EE How we figured out we had a SRE team at ...tdc-globalcode
This document discusses how to build APIs productively using Spring Boot, Spring MVC, and Spring Data. It covers how Spring Boot helps with dependency management, embedded servlet containers, and auto-configuration. Spring MVC is described as providing simplicity in API exposure and serialization/deserialization. Spring Data provides standard repository implementations and abstraction for data access across different data sources, including support for caching.
Data binding is a process that establishes a connection between an application's UI and its business logic so that when data changes, it is reflected in the UI and vice versa. Android introduced data binding in 2015 to minimize glue code between layouts and logic. The key steps to using data binding are: 1) adding the data binding library, 2) applying binding to layouts, 3) creating data binding objects, and 4) doing the binding in activities/fragments. Data binding supports observable objects to automatically update views when data changes. It allows binding layout properties like visibility and text fields.
The document discusses Magento's rendering system and how it generates output for the customer. The main goals of rendering are to generate headers and response body. It describes how controllers dispatch requests and set the response body. Layout, blocks and templates are loaded to generate the final HTML output. Key aspects covered include loading and building the layout, finding template files, and directly including templates to render block output.
Un moteur de recherche NoSQL pour chercher^H^H^H^H^H^H^H^H trouver...David Pilato
Vous cherchez toujours dans vos données avec des SELECT * FROM person WHERE name like '%david%pilato%" ?
Au delà des performances obtenues, êtes-vous certain de renvoyer les résultats les plus pertinents pour vos utilisateurs d'abord ?
Venez découvrir comment un moteur de recherche vous aidera à répondre aux questions posées par vos utilisateurs, de manière pertinente et efficace, tout en apportant des fonctionnalités d'analyse des résultats et ce, quelque soit le volume...
Would you like to make your Android UI code cleaner and more reactive? Android data binding can help. In this talk you’ll learn everything you need to know about data binding, including why it’s so powerful and how to use it effectively. If you haven’t tried data binding in the past, that’s okay! We’ll start with the basics, assuming no prior knowledge and slowly move into more advanced topics, such as 2-way binding, binding adapters, converters, best practices and common pitfalls to avoid.
The document provides an overview and agenda for a React.js training covering key concepts like components, state, props, lifecycle methods, and hooks. It also discusses React rendering, JSX syntax, and the use of Redux for application state management. The training covers React core concepts in the first half and introduces Redux and hooks in the second half, ending with a discussion of popular React libraries and tools.
The document discusses the importance of unit testing and describes how developers are returning to write good tests after cutting corners during economic difficulties. It provides examples of unit tests being written for an order management system using PHPUnit to test the createOrder method by mocking dependencies and asserting the return value.
The best practices approach for organizing Android applications into logical components has been widely debated by the developer community over the last several years. If you’ve had trouble choosing between MVC, MVP, MVVM and Reactive Architectures, or even understanding how they differ exactly, you’re not alone! Up until now, there has been no official guidance from Google, however at IO’17, Google announced Android Architecture Components as a recommended pattern moving forward. In this session you’ll learn how these architectural patterns relate to each other and the motivations behind each. You’ll also learn how to apply Android Architecture Components effectively through from live code and interactive demonstrations.
PHPUnit is a test suite framework that is widely used for PHP projects. It provides improvements over older testing frameworks like SimpleTest, including better command line tools, code coverage reports, assertions, mock objects, and tool chain support. PHPUnit uses annotations and assertions to make tests stricter and more consistent. It supports features like fixtures, mock objects, and code coverage reporting to help test codebases thoroughly. PHPUnit can be run from the command line or a web interface, and integrates with continuous integration servers to run tests automatically.
With modern JavaScript frameworks like ExtJS, SproutCore or qooxdoo, it is possible to create very rich user interfaces using only open web standards. But how do they do it? How do they work internally?
In this talk I will open the thorax of a simple qooxdoo widget and look at the various layers and building blocks used to implement it. You will learn how the widget is represented in the DOM, how events are handled, and how the layout engine works. Often there is more than a single way to achieve something. In those cases the different options and qooxdoo's specific design decision will be presented.
http://fr.droidcon.com/2014/agenda/
http://fr.droidcon.com/2014/agenda/detail?title=Deep+Dive+Into+State+Restoration
Come learn about how Android saves state in general in order to be able to restore an application in the exact same state the process was prior being killed because of a low memory condition or a configuration change. In this talk we will mainly focus on the Parcelable and Parcel objects and how Android uses them to save/restore some important stateful information such as the complete UI state.
Speaker : Cyril Mottier, Capitaine Train
Cyril Mottier is Mobile Software Engineer at Capitaine Train and Android Google Developer Expert. Passionate about technology and design, Cyril is an avid lover of Android and a multi-skilled engineer. He is actively involved in the Android community and shares his passion writing blog posts, creating open source librairies and giving talks. His motto: “Do less, but do it insanely great”
The document discusses various topics related to developing reactive web applications, including:
- Factors that determine how reactive an application needs to be such as its lifespan, team size, and complexity.
- Examples of code written in TypeScript/JavaScript for modeling ingredients and thresholds, implementing forms and routing.
- A comparison of React and Angular, noting React has less code/dependencies but lacks routing/forms out of the box, while Angular has more boilerplate initially but offers more functionality.
- Thanks given to contributors on the project.
The document introduces the Spring framework. It discusses how Spring aims to simplify Java EE development while maintaining power. It covers key Spring concepts like dependency injection, aspect oriented programming (AOP), and transaction management. It also provides examples of how to configure data access, manage dependencies, and apply aspects using Spring's XML configuration or annotations.
This document discusses quality assurance (QA) for PHP projects. It introduces various QA tools and techniques including syntax checking, documentation, testing, version control and code coverage. Screenshots are provided to illustrate concepts like detecting bugs early, observing behavior and preventing mistakes. The document also includes exercises for attendees to practice setting up version control with Git, running syntax checks with PHP Lint, generating documentation with phpDocumentor, and testing models with PHPUnit.
The document discusses why object-oriented jQuery code should be avoided. It recommends using an event-driven approach instead, where components trigger events to communicate rather than calling methods directly. This fits more cleanly with asynchronous requirements and how users typically interact with elements like autocompleters. The document provides an example of building tab functionality in an event-driven way by binding to click and keypress events that trigger a tabactivate event.
1. The document discusses the low-level API in Google App Engine for Java. It explains how the low-level API allows direct access to services like Datastore without higher-level frameworks.
2. Key concepts covered include the Datastore service, entities, keys, queries, transactions. It provides code examples for storing and retrieving entities using the low-level API.
3. Alternative high-level APIs are mentioned, like JDO and JPA, but the document focuses on explaining the lower-level implementation details and capabilities provided by the raw App Engine services.
The document discusses refactoring legacy PHP code, specifically dealing with code that has no separation between PHP and HTML. It recommends separating code into controllers and views by gathering all code, separating controller and view code, assigning variables to a view object, changing variable references in the view code, and splitting the files. Specific problems in legacy PHP code like no separation of concerns, global variables, and reliance on includes can be addressed through techniques like creating view classes, encapsulating logic in objects, and wrapping includes in functions to untangle dependency webs. The goal is to safely change code implementation without changing behavior through refactoring.
ONE MORE TIME ABOUT CODE STANDARDS AND BEST PRACTICESDrupalCamp Kyiv
In agile world when requirements changes faster than tasks got "done" status, we forced to make fast solutions that will work here and now. Being under pressure and in strict dead lines it easy to ignore code standards, "drupal way", and best practices that could be found in top Drupal sites. Tools and tips to keep your code clean.
https://drupalcampkyiv.org/node/37
The document discusses unit testing Zend Framework applications. It begins by explaining the importance of testing and some common excuses for not testing. It then provides examples of setting up PHPUnit configuration and bootstrap files for testing Zend Framework applications. The document demonstrates how to write tests for Zend Forms and models, including testing with both valid and invalid data. It shows how to modify models to add validation filters and validators.
The document discusses unit testing Zend Framework applications. It provides an overview of setting up PHPUnit for testing, including creating a phpunit.xml file and TestHelper bootstrap file. It also discusses testing Zend Forms and Models, including writing tests to validate form data and test that models are empty on construction. Code examples are provided for writing tests for a CommentForm and CommentModel class.
In 2010, I told everyone how to start unit testing Zend Framework applications. In 2011, let’s take this a step further by testing services, work flows and performance. Looking to raise the bar on quality? Let this talk be the push you need to improve your Zend Framework projects.
This document contains code for a C# class called "test" that defines properties and validation attributes for a web form model. It includes properties for email, name, date, and other fields, along with attributes for validation rules like required, data type, length, and regular expressions. It also contains JavaScript code to add client-side validation logic and datepicker functionality to the form fields.
Why is DI so great? Learn about the basics concepts of Dependency Injection and how to efficiently utilise it with Vaadin 8. This talk is from Vaadin DevDay series and features some cool ideas how developers can be the most out of Vaadin and Spring Framework
Binding business data to vaadin componentsPeter Lehto
There are two main differences between setPropertyDataSource() and setContainerDataSource() for Vaadin components:
1. Data source type - setPropertyDataSource() binds the component to a single property, while setContainerDataSource() binds it to a full Container which can contain multiple items and properties.
2. Data binding - setPropertyDataSource() binds the component value to a specific property of the current item. setContainerDataSource() does not directly bind the component, it just sets the container as the available options but does not automatically select any value. The component does not know which property in the container to use as the value.
So in summary:
- setPropertyDataSource() binds a single component to a specific property
Techlunch - Dependency Injection with VaadinPeter Lehto
The document discusses dependency injection (DI) with programmatic configuration. It defines DI as a mechanism where dependencies between objects are not directly created but instead satisfied by a third party - a DI container. The document outlines reasons for using DI including loose coupling and inversion of control. It provides examples of DI in Java using annotations and explains concepts such as scopes, producers and programmatic configuration. It also discusses integrating DI into Vaadin applications using CDI extensions.
Building impressive layout systems with vaadinPeter Lehto
The document discusses building layout systems for mobile, desktop, and tablet applications using Vaadin. It covers setting up navigation with views, using the UI as a bean, navigation managers, view displays, responsive design, events and security. The key lessons are that bean-based UIs provide easier enterprise integration, Vaadin supports CDI and Spring beans, the navigator API simplifies navigation, responsive design is integrated with the Valo theme, and events allow for loose coupling between scoped components.
The document provides an overview and agenda for a React.js training covering key concepts like components, state, props, lifecycle methods, and hooks. It also discusses React rendering, JSX syntax, and the use of Redux for application state management. The training covers React core concepts in the first half and introduces Redux and hooks in the second half, ending with a discussion of popular React libraries and tools.
The document discusses the importance of unit testing and describes how developers are returning to write good tests after cutting corners during economic difficulties. It provides examples of unit tests being written for an order management system using PHPUnit to test the createOrder method by mocking dependencies and asserting the return value.
The best practices approach for organizing Android applications into logical components has been widely debated by the developer community over the last several years. If you’ve had trouble choosing between MVC, MVP, MVVM and Reactive Architectures, or even understanding how they differ exactly, you’re not alone! Up until now, there has been no official guidance from Google, however at IO’17, Google announced Android Architecture Components as a recommended pattern moving forward. In this session you’ll learn how these architectural patterns relate to each other and the motivations behind each. You’ll also learn how to apply Android Architecture Components effectively through from live code and interactive demonstrations.
PHPUnit is a test suite framework that is widely used for PHP projects. It provides improvements over older testing frameworks like SimpleTest, including better command line tools, code coverage reports, assertions, mock objects, and tool chain support. PHPUnit uses annotations and assertions to make tests stricter and more consistent. It supports features like fixtures, mock objects, and code coverage reporting to help test codebases thoroughly. PHPUnit can be run from the command line or a web interface, and integrates with continuous integration servers to run tests automatically.
With modern JavaScript frameworks like ExtJS, SproutCore or qooxdoo, it is possible to create very rich user interfaces using only open web standards. But how do they do it? How do they work internally?
In this talk I will open the thorax of a simple qooxdoo widget and look at the various layers and building blocks used to implement it. You will learn how the widget is represented in the DOM, how events are handled, and how the layout engine works. Often there is more than a single way to achieve something. In those cases the different options and qooxdoo's specific design decision will be presented.
http://fr.droidcon.com/2014/agenda/
http://fr.droidcon.com/2014/agenda/detail?title=Deep+Dive+Into+State+Restoration
Come learn about how Android saves state in general in order to be able to restore an application in the exact same state the process was prior being killed because of a low memory condition or a configuration change. In this talk we will mainly focus on the Parcelable and Parcel objects and how Android uses them to save/restore some important stateful information such as the complete UI state.
Speaker : Cyril Mottier, Capitaine Train
Cyril Mottier is Mobile Software Engineer at Capitaine Train and Android Google Developer Expert. Passionate about technology and design, Cyril is an avid lover of Android and a multi-skilled engineer. He is actively involved in the Android community and shares his passion writing blog posts, creating open source librairies and giving talks. His motto: “Do less, but do it insanely great”
The document discusses various topics related to developing reactive web applications, including:
- Factors that determine how reactive an application needs to be such as its lifespan, team size, and complexity.
- Examples of code written in TypeScript/JavaScript for modeling ingredients and thresholds, implementing forms and routing.
- A comparison of React and Angular, noting React has less code/dependencies but lacks routing/forms out of the box, while Angular has more boilerplate initially but offers more functionality.
- Thanks given to contributors on the project.
The document introduces the Spring framework. It discusses how Spring aims to simplify Java EE development while maintaining power. It covers key Spring concepts like dependency injection, aspect oriented programming (AOP), and transaction management. It also provides examples of how to configure data access, manage dependencies, and apply aspects using Spring's XML configuration or annotations.
This document discusses quality assurance (QA) for PHP projects. It introduces various QA tools and techniques including syntax checking, documentation, testing, version control and code coverage. Screenshots are provided to illustrate concepts like detecting bugs early, observing behavior and preventing mistakes. The document also includes exercises for attendees to practice setting up version control with Git, running syntax checks with PHP Lint, generating documentation with phpDocumentor, and testing models with PHPUnit.
The document discusses why object-oriented jQuery code should be avoided. It recommends using an event-driven approach instead, where components trigger events to communicate rather than calling methods directly. This fits more cleanly with asynchronous requirements and how users typically interact with elements like autocompleters. The document provides an example of building tab functionality in an event-driven way by binding to click and keypress events that trigger a tabactivate event.
1. The document discusses the low-level API in Google App Engine for Java. It explains how the low-level API allows direct access to services like Datastore without higher-level frameworks.
2. Key concepts covered include the Datastore service, entities, keys, queries, transactions. It provides code examples for storing and retrieving entities using the low-level API.
3. Alternative high-level APIs are mentioned, like JDO and JPA, but the document focuses on explaining the lower-level implementation details and capabilities provided by the raw App Engine services.
The document discusses refactoring legacy PHP code, specifically dealing with code that has no separation between PHP and HTML. It recommends separating code into controllers and views by gathering all code, separating controller and view code, assigning variables to a view object, changing variable references in the view code, and splitting the files. Specific problems in legacy PHP code like no separation of concerns, global variables, and reliance on includes can be addressed through techniques like creating view classes, encapsulating logic in objects, and wrapping includes in functions to untangle dependency webs. The goal is to safely change code implementation without changing behavior through refactoring.
ONE MORE TIME ABOUT CODE STANDARDS AND BEST PRACTICESDrupalCamp Kyiv
In agile world when requirements changes faster than tasks got "done" status, we forced to make fast solutions that will work here and now. Being under pressure and in strict dead lines it easy to ignore code standards, "drupal way", and best practices that could be found in top Drupal sites. Tools and tips to keep your code clean.
https://drupalcampkyiv.org/node/37
The document discusses unit testing Zend Framework applications. It begins by explaining the importance of testing and some common excuses for not testing. It then provides examples of setting up PHPUnit configuration and bootstrap files for testing Zend Framework applications. The document demonstrates how to write tests for Zend Forms and models, including testing with both valid and invalid data. It shows how to modify models to add validation filters and validators.
The document discusses unit testing Zend Framework applications. It provides an overview of setting up PHPUnit for testing, including creating a phpunit.xml file and TestHelper bootstrap file. It also discusses testing Zend Forms and Models, including writing tests to validate form data and test that models are empty on construction. Code examples are provided for writing tests for a CommentForm and CommentModel class.
In 2010, I told everyone how to start unit testing Zend Framework applications. In 2011, let’s take this a step further by testing services, work flows and performance. Looking to raise the bar on quality? Let this talk be the push you need to improve your Zend Framework projects.
This document contains code for a C# class called "test" that defines properties and validation attributes for a web form model. It includes properties for email, name, date, and other fields, along with attributes for validation rules like required, data type, length, and regular expressions. It also contains JavaScript code to add client-side validation logic and datepicker functionality to the form fields.
Why is DI so great? Learn about the basics concepts of Dependency Injection and how to efficiently utilise it with Vaadin 8. This talk is from Vaadin DevDay series and features some cool ideas how developers can be the most out of Vaadin and Spring Framework
Binding business data to vaadin componentsPeter Lehto
There are two main differences between setPropertyDataSource() and setContainerDataSource() for Vaadin components:
1. Data source type - setPropertyDataSource() binds the component to a single property, while setContainerDataSource() binds it to a full Container which can contain multiple items and properties.
2. Data binding - setPropertyDataSource() binds the component value to a specific property of the current item. setContainerDataSource() does not directly bind the component, it just sets the container as the available options but does not automatically select any value. The component does not know which property in the container to use as the value.
So in summary:
- setPropertyDataSource() binds a single component to a specific property
Techlunch - Dependency Injection with VaadinPeter Lehto
The document discusses dependency injection (DI) with programmatic configuration. It defines DI as a mechanism where dependencies between objects are not directly created but instead satisfied by a third party - a DI container. The document outlines reasons for using DI including loose coupling and inversion of control. It provides examples of DI in Java using annotations and explains concepts such as scopes, producers and programmatic configuration. It also discusses integrating DI into Vaadin applications using CDI extensions.
Building impressive layout systems with vaadinPeter Lehto
The document discusses building layout systems for mobile, desktop, and tablet applications using Vaadin. It covers setting up navigation with views, using the UI as a bean, navigation managers, view displays, responsive design, events and security. The key lessons are that bean-based UIs provide easier enterprise integration, Vaadin supports CDI and Spring beans, the navigator API simplifies navigation, responsive design is integrated with the Valo theme, and events allow for loose coupling between scoped components.
This document discusses Vaadin, GWT, and Web Components. It contains the following key points:
1. Vaadin is a server-driven UI framework that uses GWT for client-side rendering.
2. Vaadin connectors bridge GWT and Vaadin by forming connections between client-side GWT widgets and server-side Vaadin components.
3. Web Components are emerging web standards for encapsulated custom elements that will be important in the future, but browser support is still lacking without polyfills like Polymer.
The document discusses Java Enterprise Edition 7 and the Java APIs that comprise it, including Java Persistence API, Enterprise JavaBeans, Context and Dependency Injection, and more. It then covers using these technologies with Vaadin, including managing user interfaces with CDI and structuring Vaadin apps using the Model-View-Presenter pattern. The MVP pattern aims to separate complex UI logic from rendering for cleaner code and easier testing.
Remote controlling Parrot AR drone with Vaadin & Spring Boot @ GWT.createPeter Lehto
Wouldn't it be crazy to fly a small drone or helicopter with your phone or tablet running nothing but a web browser? This session will tell you all about it!
Imagine a fully functional touch based user interface for remote controlling a small drone or a helicopter. This is doable with latest experimental integrations around drone controlling backend applications over WIFI with touch based control interface built with GWT or Vaadin. During the session such a system will be presented with full technology stack starting from GWT based frontend to the actual backend controller application.
A live drone will also be flown during the talk maintaining a safe distance from the audience.
Remote controlling Parrot AR Drone with Spring Boot & Vaadin (JavaCro15)Peter Lehto
Wouldn't it be crazy to fly a small drone or helicopter with your phone or tablet running nothing but a web browser? This session will tell you all about it!
Imagine a fully functional touch based user interface for remote controlling a small drone or a helicopter. This is doable with latest experimental integrations around drone controlling backend applications over WIFI with touch based control interface built with GWT or Vaadin. During the session such a system will be presented with full technology stack starting from GWT based frontend to the actual backend controller application written with Spring Boot.
The document discusses integrating Vaadin with Java Enterprise Edition (EE). It describes using Context and Dependency Injection (CDI) to allow Vaadin UI and view classes to be managed beans that can reference EE objects through annotations like @Inject and @EJB. This allows Vaadin applications to easily access services, repositories, and other components defined using Java EE APIs and specifications.
This document discusses cosolvency as a technique for enhancing the solubility of poorly soluble drugs. It defines solubility and outlines reasons for enhancing solubility, such as improving oral bioavailability. It then describes cosolvency, where a cosolvent is added to increase the solubility of a drug by creating a solution with an enhanced solubility. Common cosolvents that are non-toxic, non-irritating, and able to cross membranes include glycerine, PEG, diethyl acetamide, and ethyl alcohol. Cosolvency works by creating a solution with dielectric properties between those of water and the original solvent. It is a widely used technique that allows for parenteral formulations and improves
Learning Hub in Ambala ! Batra Computer Centrejatin batra
Batra Computer Centre is An ISO certified 9001:2008 training Centre in Ambala.
We Provide Learning Hub in Ambala. BATRA COMPUTER CENTRE provides best training in C, C++, S.E.O, Web Designing, Web Development and So many other courses are available.
El documento describe el origen y objetivos de WIM Perú, una filial peruana de la organización Women in Mining. WIM Perú busca fortalecer la participación de la mujer en la industria minera peruana mediante la creación de redes, intercambio de conocimientos y capacitaciones. Actualmente cuenta con 80 asociadas y sus metas a corto plazo incluyen formalizarse como organización y consolidar su membresía.
Metolar-XR (Metoprolol Capsules) is used for the treatment of hypertension (blood pressure), long-term treatment of angina pectoris, treatment of stable, symptomatic heart failure of ischemic, hypertensive or cardiomyopathic origin as well as for migraine prophylaxis.
Vaadin is a Java-based web application framework that allows building rich client-side web applications without JavaScript. The presentation discusses new features in Vaadin 7 including a renewed windowing API, Sass support for styling, redesign forms, improved RPC and state handling, and new JavaScript add-ons capabilities. It also outlines the roadmap for upcoming releases that will add server push, new charts, touch support, and integration with CDI.
The document summarizes Nicolas Frankel's presentation on Vaadin 7 at a Paris Vaadin & GWT Meetup. It covered Vaadin 7 features like SASS, connectors, and client-side extensions. It also discussed the new FieldGroup API for handling fields and data binding, providing examples of how to implement FieldGroup and customize field types. Finally, it explained converters for converting between model values and string representations without side effects.
Se guardiamo oltre la meccanica, il TDD è una tecnica complessa perché richiede molteplici skill. Da principiante dopo l’implementazione di poche storie ti imbatti nel problema dei test che si rompono ad ogni refactoring, è arrivato il momento di migliorare i propri skill di scrittura dei test. Nel talk analizzeremo la struttura dei test, quali sono le bad smell più comuni e come porvi rimedio.
This program displays, inserts, and updates staff information in a database table. It contains Java code to create a user interface with text fields to view, enter, and edit an employee's ID, name, address, city, state, and phone number. The program connects to a MySQL database, executes SQL statements to retrieve, add, and modify staff records, and includes validation of the user input fields.
This document contains code for a Java GUI application called EasyGUI that allows users to generate automation results for order processing. It contains classes like EasyGUI, EasyButton, and BatchEngine that create a GUI, handle button clicks, and execute automation batches. When the submit button is clicked, it validates the order ID, runs batches to get conversation IDs, account numbers, and CSIXML files, and displays the results. It uses GridBagLayout to arrange components on the main panel and stores selection values in variables like orderID and accountNumber to pass to batch processing methods.
This document outlines various refactoring techniques including self-encapsulating fields, replacing data values with objects, changing values to references, changing references to values, replacing arrays with objects, duplicating observed data, changing unidirectional associations to bidirectional, and changing bidirectional associations to unidirectional. Each technique is explained with examples to illustrate how it can be implemented in code.
This document discusses how to display records from a Northwind database in a JTable using NetBeans and SQL Server. It includes code to connect to the database, define a Product class with getters and setters, a ProductDAO class to retrieve data, and a GUI class to display the results in a JTable. The code retrieves product data including ID, name, category, supplier, price, quantity and units from the database and displays it in the table.
This document provides an overview of the Griffon framework for building desktop applications in Groovy and Java. It discusses key Griffon concepts like conventions over configuration, MVC patterns, built-in testing support, and automation of repetitive tasks. The document also covers Griffon features such as lifecycle scripts, binding, threading, and popular plugins. Resources for learning more about Griffon and its community are provided at the end.
Paintfree Object-Document Mapping for MongoDB by Philipp KrennJavaDayUA
This document summarizes a talk on using Morphia, an object-document mapping library for MongoDB. Morphia allows mapping Java objects to MongoDB documents using annotations, providing an object-relational mapping-style interface for MongoDB. The talk covers Morphia features like collections, indexes, queries, and patterns for normalization and inheritance. While Morphia simplifies development, the speaker notes it does not provide transactions or joins like traditional ORMs.
Vaadin 7 is an open source web application framework that allows developers to build rich client-side web applications using Java on the server-side and JavaScript on the client-side, with new features in Vaadin 7 including improved component architecture, support for SASS styling, and enhanced widget communication through state-based RPC.
This document provides an overview of event sourcing and CQRS approaches to system architecture. It discusses command handling, view handling, and writing event sourced DDD systems. It provides code examples of modeling commands, events, and aggregates in an event sourced system. It discusses benefits of event sourcing like having an audit log, horizontal scaling, and using events to power other services.
The document discusses Wicket testing and models. It provides an overview of different types of Wicket test classes for components, pages, and forms. It also discusses different model types in Wicket like PropertyModel, LoadableDetachableModel, and how models allow for dynamic updates and serialization. The document then presents examples of using a UserLoadableDetachableModel and FormTester. It also discusses making components more abstract and removing assumptions when designing them. Finally, it introduces the concept of a "CSS component" for creating consistent UI elements through CSS alone.
Vaadin 7 is an introduction to the Vaadin framework. Key ideas of Vaadin 7 include rich components, a server+client architecture that runs entirely on the Java server, and embracing the Java programming language. New features in Vaadin 7 include a renewed JavaScript architecture, Sass support, redesigned forms, and built-in high level view management. The roadmap for Vaadin 7.1 includes server push using Atmosphere, a new calendar component, and limited IE 10 support.
The document discusses SOLID principles of object-oriented design. It provides examples of code that demonstrate poor adherence to SOLID and ways the code can be refactored to better follow SOLID. Specifically, it shows how to apply the single responsibility principle, open/closed principle, Liskov substitution principle, interface segregation principle and dependency inversion principle to structure code for flexibility, reusability and maintainability.
This document provides an overview of Apache Wicket, a Java web application framework. It begins with an introduction to Wicket and its core concepts like components. It then walks through an example of creating a simple cheese store application with Wicket, including setting up the project, adding domain models and entities, and building out components. The document also discusses how to use Enterprise JavaBeans (EJBs) with Wicket, such as making data access objects (DAOs) into EJBs and injecting them.
This document provides an introduction to Vaadin, a Java-based web application framework. It highlights key features of Vaadin 7 including rich UI components, support for multiple browsers and devices, built-in themes, and an architecture that separates the user interface from the data model and server communication. The document also summarizes new features in Vaadin 7 such as a windowing API, Sass support, redesign forms, RPC and state handling, and server push capabilities.
[PHPCon 2023] “Kto to pisał?!... a, to ja.”, czyli sposoby żeby znienawidzić ...Mateusz Zalewski
Czysty kod. Jakościowe oprogramowanie. Dobre praktyki. Święte Graale pracy programisty, o których każdy z nas wie, a mimo to wciąż zachowujemy się tak, jakby ich nie było. Bo przecież ten kod to tylko na chwilę. A tego to w ogóle nie będziemy używać. A tę klasę się zrefaktoruje później. Wszyscy od czasu do czasu zaciągamy dług u samych z siebie z przyszłości - dług, którego potem (nie bez powodu) bardzo nie chcemy spłacać.
Zagłębmy się więc w ten fascynujący świat słabego oprogramowania. Przejdźmy przez las nieużytych wzorców projektowych, przebrnijmy przez bagna zagnieżdżonych pętli. Wejdźmy na kolejny ośmiotysięcznik, a może z jego szczytu uda nam się dojrzeć zatokę pięknego kodu - w której, miejmy nadzieję, tym razem pozostaniemy na dłużej.
This document discusses how JavaScript code would look if Java was written in JavaScript. It provides examples of Java-like classes and methods written in JavaScript. It also discusses JavaScript design patterns like the Module pattern and MVC frameworks. Finally, it covers topics like unit testing JavaScript with Jasmine, SVG vs Canvas for graphs, and libraries like Underscore.js and CSS frameworks.
Similar to Vaadin 8 - Data Binding with Binder (20)
Top Benefits of Using Salesforce Healthcare CRM for Patient Management.pdfVALiNTRY360
Salesforce Healthcare CRM, implemented by VALiNTRY360, revolutionizes patient management by enhancing patient engagement, streamlining administrative processes, and improving care coordination. Its advanced analytics, robust security, and seamless integration with telehealth services ensure that healthcare providers can deliver personalized, efficient, and secure patient care. By automating routine tasks and providing actionable insights, Salesforce Healthcare CRM enables healthcare providers to focus on delivering high-quality care, leading to better patient outcomes and higher satisfaction. VALiNTRY360's expertise ensures a tailored solution that meets the unique needs of any healthcare practice, from small clinics to large hospital systems.
For more info visit us https://valintry360.com/solutions/health-life-sciences
E-Invoicing Implementation: A Step-by-Step Guide for Saudi Arabian CompaniesQuickdice ERP
Explore the seamless transition to e-invoicing with this comprehensive guide tailored for Saudi Arabian businesses. Navigate the process effortlessly with step-by-step instructions designed to streamline implementation and enhance efficiency.
Microservice Teams - How the cloud changes the way we workSven Peters
A lot of technical challenges and complexity come with building a cloud-native and distributed architecture. The way we develop backend software has fundamentally changed in the last ten years. Managing a microservices architecture demands a lot of us to ensure observability and operational resiliency. But did you also change the way you run your development teams?
Sven will talk about Atlassian’s journey from a monolith to a multi-tenanted architecture and how it affected the way the engineering teams work. You will learn how we shifted to service ownership, moved to more autonomous teams (and its challenges), and established platform and enablement teams.
What to do when you have a perfect model for your software but you are constrained by an imperfect business model?
This talk explores the challenges of bringing modelling rigour to the business and strategy levels, and talking to your non-technical counterparts in the process.
SMS API Integration in Saudi Arabia| Best SMS API ServiceYara Milbes
Discover the benefits and implementation of SMS API integration in the UAE and Middle East. This comprehensive guide covers the importance of SMS messaging APIs, the advantages of bulk SMS APIs, and real-world case studies. Learn how CEQUENS, a leader in communication solutions, can help your business enhance customer engagement and streamline operations with innovative CPaaS, reliable SMS APIs, and omnichannel solutions, including WhatsApp Business. Perfect for businesses seeking to optimize their communication strategies in the digital age.
Artificia Intellicence and XPath Extension FunctionsOctavian Nadolu
The purpose of this presentation is to provide an overview of how you can use AI from XSLT, XQuery, Schematron, or XML Refactoring operations, the potential benefits of using AI, and some of the challenges we face.
Using Query Store in Azure PostgreSQL to Understand Query PerformanceGrant Fritchey
Microsoft has added an excellent new extension in PostgreSQL on their Azure Platform. This session, presented at Posette 2024, covers what Query Store is and the types of information you can get out of it.
Mobile App Development Company In Noida | Drona InfotechDrona Infotech
Drona Infotech is a premier mobile app development company in Noida, providing cutting-edge solutions for businesses.
Visit Us For : https://www.dronainfotech.com/mobile-application-development/
Mobile App Development Company In Noida | Drona Infotech
Vaadin 8 - Data Binding with Binder
1. B U S I N E S S D ATA B I N D I N G
FOR VAADIN (8) APPLICATIONPETER LEHTO
@peter_lehto
2. Session’s content
• The Good Ol’ Boy - Vaadin 7
• The Brand New Field Model of Vaadin 8
• CustomField<T>
• Where are my Items & Properties?
• Being Lazy & Happy without Containers
3. Session’s content
• The Good Ol’ Boy - Vaadin 7
• The Brand New Field Model of Vaadin 8
• CustomField<T>
• Where are my Items & Properties?
• Being Lazy & Happy without Containers
4. H o w w o u l d y o u e d i t
c u s t o m e r r e c o r d s ?
VAADIN 7
5. @Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
No data binding
VAADIN 7
6. @Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
No data binding
VAADIN 7
7. @Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
firstName.addValueChangeListener(new ValueChangeListener() {
@Override
public void valueChange(ValueChangeEvent event) {
customer.setFirstName(firstName.getValue());
}
});
No data binding
VAADIN 7
8. @Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
firstName.addValueChangeListener(new ValueChangeListener() {
@Override
public void valueChange(ValueChangeEvent event) {
customer.setFirstName(firstName.getValue());
}
});
lastName.addValueChangeListener(new ValueChangeListener() {
@Override
public void valueChange(ValueChangeEvent event) {
customer.setLastName(lastName.getValue());
}
});
No data binding
VAADIN 7
9. @Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
firstName.addValueChangeListener(new ValueChangeListener() {
@Override
public void valueChange(ValueChangeEvent event) {
customer.setFirstName(firstName.getValue());
}
});
lastName.addValueChangeListener(new ValueChangeListener() {
@Override
public void valueChange(ValueChangeEvent event) {
customer.setLastName(lastName.getValue());
}
});
layout.addComponents(firstName, lastName);
setContent(layout);
}
No data binding
VAADIN 7
10. @Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
firstName.addValueChangeListener(new ValueChangeListener() {
@Override
public void valueChange(ValueChangeEvent event) {
customer.setFirstName(firstName.getValue());
}
});
lastName.addValueChangeListener(new ValueChangeListener() {
@Override
public void valueChange(ValueChangeEvent event) {
customer.setLastName(lastName.getValue());
}
});
layout.addComponents(firstName, lastName);
setContent(layout);
}
• Setters used explicitly
• Every Field has a Listener
• No way to Save / Cancel
• Lots of code
• Prone to error and change
• Invalid values not prevented
WHAT’S WRONG?
11. @Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
LET’S IMPROVE!
12. @Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
Button save = new Button("Save", new Button.ClickListener() {
@Override
public void buttonClick(ClickEvent event) {
customer.setFirstName(firstName.getValue());
customer.setLastName(lastName.getValue());
}
});
layout.addComponents(firstName, lastName, save);
setContent(layout);
}
LET’S IMPROVE!
13. • Centralized value setting
• Validation could be added
BENEFITS? @Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
Button save = new Button("Save", new Button.ClickListener() {
@Override
public void buttonClick(ClickEvent event) {
customer.setFirstName(firstName.getValue());
customer.setLastName(lastName.getValue());
}
});
layout.addComponents(firstName, lastName, save);
setContent(layout);
}
14. • Setters used explicitly
• Lots of code
• Prone to error and change
• Hard to Validate
@Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
Button save = new Button("Save", new Button.ClickListener() {
@Override
public void buttonClick(ClickEvent event) {
customer.setFirstName(firstName.getValue());
customer.setLastName(lastName.getValue());
}
});
layout.addComponents(firstName, lastName, save);
setContent(layout);
}
WHAT’S WRONG?
15. @Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
With properties
VAADIN 7
16. @Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
FieldGroup fieldGroup = new FieldGroup();
fieldGroup.bind(firstName, "firstName");
fieldGroup.bind(lastName, "lastName");
fieldGroup.setItemDataSource(new
BeanItem<CustomerDTO>(customer));
With properties
VAADIN 7
17. With properties
VAADIN 7
@Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
FieldGroup fieldGroup = new FieldGroup();
fieldGroup.bind(firstName, "firstName");
fieldGroup.bind(lastName, "lastName");
fieldGroup.setItemDataSource(new
BeanItem<CustomerDTO>(customer));
Button save = new Button("Save", new Button.ClickListener() {
@Override
public void buttonClick(ClickEvent event) {
try {
fieldGroup.commit();
}
catch(CommitException e) {
// show errors
}
}
});
18. • No more explicit setters
• Committable / Discardable
• Validation part of Commit
@Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
FieldGroup fieldGroup = new FieldGroup();
fieldGroup.bind(firstName, "firstName");
fieldGroup.bind(lastName, "lastName");
fieldGroup.setItemDataSource(new
BeanItem<CustomerDTO>(customer));
Button save = new Button("Save", new Button.ClickListener() {
@Override
public void buttonClick(ClickEvent event) {
try {
fieldGroup.commit();
}
catch(CommitException e) {
// show errors
}
}
});
BENEFITS?
19. • Not type safe
• Prone to error and change
• BeanItem boiler plate and
Checked CommitException
@Override
protected void init(VaadinRequest vaadinRequest) {
VerticalLayout layout = new VerticalLayout();
TextField firstName = new TextField("Firstname");
TextField lastName = new TextField("Lastname");
CustomerDTO customer = new CustomerDTO();
FieldGroup fieldGroup = new FieldGroup();
fieldGroup.bind(firstName, "firstName");
fieldGroup.bind(lastName, "lastName");
fieldGroup.setItemDataSource(new
BeanItem<CustomerDTO>(customer));
Button save = new Button("Save", new Button.ClickListener() {
@Override
public void buttonClick(ClickEvent event) {
try {
fieldGroup.commit();
}
catch(CommitException e) {
// show errors
}
}
});
WHAT’S WRONG?
21. Session’s content
• The Good Ol’ Boy - Vaadin 7
• The Brand New Field Model of Vaadin 8
• CustomField<T>
• Where are my Items & Properties?
• Being Lazy & Happy without Containers
22. c . v. u i . A b s t r a c t F i e l d < T >
VAADIN 7
1 8 5 3 l o c 2 1 3 l o c
VAADIN 8
49. TextField yearOfBirth = …
Customer customer = …
customer.setYearOfBirth(1984);
BeanBinder<CustomerDTO> binder = new BeanBinder<>(CustomerDTO.class);
binder.forField(yearOfBirth)
.withValidator(value -> value.length() == 4, "Must have 4 characters")
.withConverter(Integer::valueOf, String::valueOf)
.withValidator(value -> value < 2000, "Must be before year 2000")
Validation with
Conversion
VAADIN 8
50. TextField yearOfBirth = …
Customer customer = …
customer.setYearOfBirth(1984);
BeanBinder<CustomerDTO> binder = new BeanBinder<>(CustomerDTO.class);
binder.forField(yearOfBirth)
.withValidator(value -> value.length() == 4, "Must have 4 characters")
.withConverter(Integer::valueOf, String::valueOf)
.withValidator(value -> value < 2000, "Must be before year 2000")
.bind(CustomerDTO::getYearOfBirth, CustomerDTO::setYearOfBirth);
Validation with
Conversion
VAADIN 8
51. TextField yearOfBirth = …
Customer customer = …
customer.setYearOfBirth(1984);
BeanBinder<CustomerDTO> binder = new BeanBinder<>(CustomerDTO.class);
binder.forField(yearOfBirth)
.withValidator(value -> value.length() == 4, "Must have 4 characters")
.withConverter(Integer::valueOf, String::valueOf)
.withValidator(value -> value < 2000, "Must be before year 2000")
.bind(CustomerDTO::getYearOfBirth, CustomerDTO::setYearOfBirth);
Button save = new Button("Save", e -> {
try {
binder.writeBean(customer);
} catch (ValidationException ve) {
ve.getFieldValidationErrors().forEach(error -> …);
}
});
Validation with
Conversion
VAADIN 8
52. Session’s content
• The Good Ol’ Boy - Vaadin 7
• The Brand New Field Model of Vaadin 8
• CustomField<T>
• Where are my Items & Properties?
• Being Lazy & Happy without Containers
60. Session’s content
• The Good Ol’ Boy - Vaadin 7
• The Brand New Field Model of Vaadin 8
• CustomField<T>
• Where are my Items & Properties?
• Being Lazy & Happy without Containers
86. public class Query<F> {
int getOffset();
int getLimit();
List<SortOrder<String>> getSortOrders();
Optional<F> getFilter();
}
87. T h e c l a s s i c C o n t a i n e r d i s c r e p a n c y
VAADIN 7
88. Grid grid = new Grid();
grid.addColumn("firstName");
grid.addColumn("lastName");
grid.addColumn("yearsOld");
grid.setContainerDataSource(
new BeanItemContainer<>(CustomerDTO.class));
89. HTTP Status 500 - com.vaadin.server.ServiceException:
java.lang.IllegalStateException:
Found at least one column in Grid that does not exist
in the given container: yearsOld with the header “Years
Old”.
Call removeAllColumns() before setContainerDataSource()
if you want to reconfigure the columns based on the new
container.
91. Grid grid = new Grid();
grid.addColumn("firstName");
grid.addColumn("lastName");
grid.addColumn("yearsOld");
92. Grid grid = new Grid();
grid.addColumn("firstName");
grid.addColumn("lastName");
grid.addColumn("yearsOld");
GeneratedPropertyContainer generatedProps =
new GeneratedPropertyContainer(
new BeanItemContainer<>(CustomerDTO.class));
generatedProps.addContainerProperty("yearsOld", Integer.class, null);
grid.setContainerDataSource(generatedProps);
93. HTTP Status 500 - com.vaadin.server.ServiceException: java.lang.UnsupportedOperationException:
GeneratedPropertyContainer does not support adding properties.
104. Lessons learned
• Vaadin 8 - built on Java 8
• Lambdas and Functional paradigm at large
• DataBinding completely redone
• Targets simplifications and flexibility
• Drops Containers, Items and Properties
• Gathers all DataBinding to Binder
105. T H A N K Y O U !
PLEASE RATE THE TALK
@
FLIP CHART BY THE DOOR!
@peter_lehto