This document introduces the Vaadin framework, which is a user interface framework for building rich web applications. It discusses how Vaadin enables developer productivity through features like user interface components, automated communication between the client and server, and support for multiple devices. The document also covers trends in web frameworks like AngularJS and web components, and how Vaadin is exploring these trends through new components in Vaadin Labs and building web components with GWT.
The document discusses the history and future of the Vaadin framework. It outlines how Vaadin has evolved from GWT-based widgets to modern web components using the Polymer library. It describes how Vaadin 10 introduces Vaadin Components that are built as reusable web components, allowing developers to create user interfaces with modern APIs and structure. The talk also covers how Vaadin now uses functional data binding with its Binder class to simplify editing and validation of business objects.
Rock Your Web Apps with Vaadin: Coding Serbia 2014Ville Ingman
This document discusses Vaadin, an open-source framework for building web applications. Some key points:
- Vaadin allows developers to write web applications completely in Java without using JavaScript, making development faster and easier.
- It has over 100,000 developers from more than 6,000 cities using it and 470 add-ons available. Typical use cases include enterprise applications like ERPs.
- The document provides an overview of Vaadin's architecture, features like themes and add-ons, and how to get started using it with Eclipse, IntelliJ, NetBeans or Maven.
[FEConf Korea 2017]Angular 컴포넌트 대화법Jeado Ko
This document summarizes Angular component communication patterns. It discusses using @Input and @Output to communicate between parent and child components. It also covers using a shared service to communicate between siblings and across the component tree. Services can utilize BehaviorSubject to share state updates through observables. Larger applications may use a state management library like NgRx to introduce a single source of truth via a centralized store.
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.
This document discusses using Polymer to build web component-based applications. It begins by explaining what web components are and how browsers support them through standards like custom elements, HTML imports and templates. It then introduces Polymer as a library that helps build web components and provides ready-made reusable components. The document outlines how to build full-stack apps with Polymer, including using Spring Boot on the backend to provide features like authentication. It also covers tools like Vulcanize, Crisper and build optimizations to improve performance of Polymer apps.
This document provides an overview and introduction to web components. It discusses the key aspects of web components including custom elements, HTML imports, shadow DOM, and templates. It also shows how web components allow building reusable custom elements that encapsulate their styles and functionality independently of the page they are used in. The document demonstrates how to define and register a custom element for displaying activity cards and use templates and shadow DOM to encapsulate its implementation.
Introduction to React for Frontend DevelopersSergio Nakamura
The document provides an introduction to React for frontend developers. It discusses why React is useful, including its declarative style, automatic updates, use of a virtual DOM, and modular component structure. It then covers React basics like building functional components, what JSX is, and how to use JavaScript code within JSX.
Presentation about Apache Wicket given at FOSDEM 2011. Apache Wicket is an open source, component oriented Java web framework. This presentation features an introduction to the Wicket framework and showcases some of the new features in the upcoming 1.5 release of Wicket.
JavaFX is used by many companies and organizations for a variety of applications. Some key uses of JavaFX include:
- Embedded applications, including on devices like phones and set-top boxes.
- Mobile applications, as JavaFX supports deploying to iOS and Android.
- Web applications, with JavaFX code running in browsers using a plugin or port to HTML5.
- Traditional desktop applications, where JavaFX can provide a modern user interface for programs.
- Specific examples given include office management software by an AIDS foundation in Germany.
Oleh Zasadnyy "Progressive Web Apps: line between web and native apps become ...IT Event
Over the years developers were used to thing that web is not user-friendly, performance efficient and powerful as native apps. But things have been changed so far; now you can build offline applications with notifications, Bluetooth and camera access and so on. Web development is great again.
- Quick startup - I will show how to prioritize content loading in the application to show users meaningful pixels as soon as possible
- Progressive enhancement - I will encourage you to use maximum of the platform but still support earlier browsers
- Offline application - here I will explain how you can easily make your web application working offline
- Push Notifications - one of the best way to increase conversion of your application and now it's possible on the web. I am going to show how to do it right with few steps.
- Experimental APIs - I will show how to sign in once on all your devices with Credential API, use native share menu and make payments in few clicks
The document discusses Vaadin, a technology that empowers developers to build web apps for business purposes. Vaadin prioritizes developer productivity by simplifying the developer experience and saving developers' time so they can focus on building great user interfaces. The founder and CEO hopes that users are as excited about living and breathing the Vaadin brand, which aims to fight for simplicity for both users and developers.
The web - What it has, what it lacks and where it must go - IstanbulRobert Nyman
The document discusses the current state and future of the web. It describes how the web currently lacks capabilities that native mobile apps have like push notifications, background processing, and offline access. However, new web features being developed like Service Workers, Push Notifications, and Background Sync aim to address these gaps. The document argues that with these new features, the divide between native and web is diminishing and the web can provide an app-like experience without requiring users to download an app. The future of the web depends on further developing these capabilities and ensuring the web remains accessible, simple to use, and continues to work across all platforms.
Windows Store app using XAML and C#: Enterprise Product Development Mahmoud Hamed Mahmoud
This document provides an agenda and overview for a presentation on building Windows Store apps using XAML and C#. The presentation will demonstrate the Kona project, a sample Windows Store app, and how to build and test a Windows Store app using Team Foundation Build. It will also cover globalization, logging, MVVM pattern, navigation, and visual state support in Windows Store apps. The presentation aims to provide tips and best practices for enterprise product development of Windows Store apps.
The document discusses the history and future of the Vaadin framework. It outlines how Vaadin has evolved from version 1 through version 8 to incorporate new technologies like Web Components and Polymer. It describes how Vaadin Components and Vaadin Flow represent the next generation of Vaadin apps, built with these modern web standards to provide a simpler development model and better performance. Vaadin Flow uses declarative composition, new UI components, latency compensation through event handlers, and client-side views to develop apps.
Presentation about the features of JavaFX. See how to use video, different deployment types, JavaScript integration, annimations and more. Demo's not included.
How to Build ToDo App with Vue 3 + TypeScriptKaty Slemon
Here’s a comprehensive step-by-step tutorial on how to get started with Vue Typescript. Let’s understand building To-do application combining Vue 3 + Typescript.
This document discusses Android data binding. It begins by explaining what data binding is and providing simple examples of how to bind data to views using strings, objects, and variables. It then covers more advanced topics like creating a data binding class, setting variable values, two-way binding, binding adapters, using data binding with RecyclerView, and the performance benefits of data binding.
It’s trivial today to start writing and debugging some React code, but it’s not 100% clear how to properly deploy the application, manage versions and what implications that has on the build configurations. Especially if you want to allow different versions for different users in order to perform some A/B testing, testing new features in production environment, come up with some UI experiments, or gradually roll out new features for a subset of users.
In this presentation I hopefully covered all that.
A guide to create a simple Java application and upload it to the Google Cloud Platform with Google App Engine. This presentation covers usage of persistence API with both Google Cloud SQL and Google Cloud Datastore.
Google Web Toolkit
Presentation by Assoc.Prof. Dr.Thanachart Numnonda & Asst.Prof. Thanisa Kruawaisayawan, Mini Master of Java Technology KMITL, July 2012
Java Web Programming on Google Cloud Platform [3/3] : Google Web ToolkitIMC Institute
Google Web Toolkit (GWT) is an open source Java framework that allows web developers to create Ajax applications in Java and deploy them as optimized JavaScript. GWT provides tools for building AJAX applications in Java that are compiled into JavaScript for cross-browser compatibility. It handles browser inconsistencies and integrates with existing Java development tools, allowing developers to build and debug Rich Internet Applications using Java instead of JavaScript.
Presented at Big Android BBQ 2015
Hurst Convention Center, Hurst Texas
This talk will cover Fragments in detail by comparing and contrasting them to something we know well, Activities. We will also cover examples and use cases. Fragments: Why, How, and What For? is targeted toward developers who may not have had a lot of experience using Fragments and those who want to understand them better. Why did Google introduce Fragments? Aren’t Activities enough? How do Fragments work? What For? Example and use cases such as Fragment reuse, single pane vs multi-pane, ViewPager, NavigationDrawer and DialogFragment.
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.
Workshop on how to build Vaadin Add-ons. We introduce two styles of building Vaadin add-on components for Vaadin: integrating an existing GWT widget (DatePicker), and integrating an existing JavaScript library (three.js).
This document provides an overview of Vaadin, an open-source web application framework that allows developers to build rich web applications using pure Java code. Key points covered include: Vaadin uses a client-server architecture with a Java backend and GWT frontend; the app lifecycle and how UI instances are managed; common patterns for structuring apps using views and navigation; building responsive layouts; server push for real-time updates; data binding between fields and data models; and how to get started with Vaadin.
Vaadin Framework provides a desktop-like programming model for creating modern web applications in plain Java – without the need for HTML, XML, plug-ins or JavaScript. This session explains the key concepts of the server-side and client-side RIA development with Java as well as summarizes what is new with Vaadin 7 and how it relates to GWT. To demonstrate the use of the framework, an example application is developed during the session step-by-step.
AtlasCamp 2015: Connect everywhere - Cloud and ServerAtlassian
Patrick Streule
You have an idea for an add-on? You want to tap into both the Atlassian Cloud and Server customer base without writing and maintaining it twice? Patrick illustrates some techniques you can use today to share most of your code between the Connect and the P2 add-on implementation.
HTML5 introduces new semantic elements like article, header, nav, and section that divide the content into meaningful regions. It also defines new multimedia elements such as video, audio, and canvas. New form input types and attributes are added for validation. The Canvas API allows dynamic drawing via scripting. The Drag and Drop API supports dragging and dropping elements. Other HTML5 APIs include Geolocation, Web Storage, and Web Workers. Overall, HTML5 provides a powerful set of features for building robust, dynamic web applications.
This document discusses building mobile applications using PhoneGap, jQuery, and Dreamweaver. It provides an overview of different mobile application types including mobile HTML, web apps, hybrid apps, and native apps. It then demonstrates how to create hybrid mobile apps with PhoneGap and jQuery Mobile, including accessing device APIs, building user interfaces with jQuery Mobile, and creating customizable PhoneGap plugins.
This document discusses building mobile applications using PhoneGap, jQuery, and Dreamweaver. It provides an overview of different mobile application types including mobile HTML, web apps, hybrid apps, and native apps. It then demonstrates how to create hybrid mobile apps with PhoneGap and jQuery Mobile, including accessing device APIs, building user interfaces with jQuery Mobile, and creating lists and charts with JavaScript plugins. It also covers how to package and deploy the app to different platforms using PhoneGap.
06. Android Basic Widget and ContainerOum Saokosal
This document discusses widgets and containers in Android layouts. It provides examples of common widgets like TextView, ImageView, Button, EditText, CheckBox and DigitalClock. It also demonstrates different container layouts, including LinearLayout, RelativeLayout and TableLayout. Code snippets are given to illustrate how to declare these widgets and containers in an XML layout file named main.xml.
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.
Building Modern Apps using Android Architecture ComponentsHassan Abid
Android architecture components are part of Android Jetpack. They are a collection of libraries that help you design robust, testable, and maintainable apps. In this talk, We will cover LiveData, ViewModel, Room and lifecycle components. We will go through practical code example to understand modern android app architecture especially MVVM architecture.
The document discusses the history and future of building web applications using components. It begins by explaining the traditional client-server model and then transitions to discussing newer approaches like REST APIs and single-page applications built with components. It covers topics like building custom elements, using frameworks like Polymer, and the growing capabilities of the web platform for creating reusable UI components. The overall message is that the web is moving towards a more component-based approach to building applications in order to improve developer productivity and user experience.
Front End Development for Back End Java Developers - Jfokus 2020Matt Raible
The document is a presentation about front end development for back end Java developers. It discusses topics like JavaScript, TypeScript, build tools, CSS frameworks, front end performance, and progressive web apps. It also provides introductions and comparisons of popular JavaScript frameworks like Angular, React, and Vue. The presentation encourages attendees to learn new front end skills and try building something with a front end framework.
The document discusses building mobile web applications using HTML5. It covers topics like HTML5 features that are well supported on mobile browsers like forms, communication, canvas, geolocation, audio and video. It provides examples of using CSS3 for styling, animation and media queries for responsive design. It also discusses utilizing HTML5 APIs for advanced interactions, graphics, offline support, performance and accessing device capabilities.
This document provides an overview of a presentation on using D3 for data visualization on desktops, smartphones, and Google Glass. It discusses how D3 works, examples of basic charts like scatter plots and bar charts using D3, and how to incorporate features like mouse interactions, animations, filters and gradients. It also covers using D3 with technologies like Android, PhoneGap, and Google Glass to create mobile visualizations.
This document provides an overview of a presentation on using D3 for data visualization on desktops, smartphones, and Google Glass. It discusses topics like what D3 is, how it works, examples of creating simple charts and adding interactivity with mouse events, using SVG filters and gradients, and integrating D3 visualizations into Android and Google Glass apps. It also briefly mentions related technologies, resources for learning more, and potential training topics.
The document discusses a hybrid web application architecture that combines client-side and server-side technologies. It presents layers of a typical web application and compares approaches that are fully client-side, fully server-side, or hybrid. The hybrid approach aims to achieve a 50% reduction in development and maintenance time compared to fully client-side or server-side approaches. It also discusses benefits and tradeoffs around productivity, control, and offline capabilities. Code examples are provided to illustrate implementing a hybrid address book application using Vaadin on the server-side and GWT-RPC on the client-side.
Vaadin is a Java-based web application framework that allows building rich web UIs for desktop and mobile. It introduces new features in version 7 like support for Sass and new redesigned forms. The framework aims to improve developer productivity by handling browser compatibility and only requiring developers to write Java code.
Vaadin is a Java-based web application framework that allows building rich client-side web applications using server-side Java. It provides over 350 reusable UI components and supports major browsers. Vaadin handles communicating between the server-side Java code and browser-based JavaScript, allowing developers to write code once that works across all devices without needing browser plugins. Vaadin embraces Java and runs on any JVM, supporting technologies like Servlets, Portlets, and most cloud platforms.
This document discusses web application architectures and frameworks. It begins by explaining the typical layers of a web application, including the backend server, web server, and client-side UI. It then discusses different approaches for building the client-side UI, including using only JavaScript, frameworks like GWT that compile to JavaScript, and server-side frameworks like Vaadin that handle most of the UI on the server. The rest of the document provides examples of implementing applications using these different approaches and frameworks, discusses considerations around complexity, performance and developer productivity. It focuses on explaining the benefits of using a hybrid approach and Vaadin in particular, which allows developing the UI on the server but keeps it fast and responsive on the client-side.
1) Software architecture can introduce risks if it prepares for changes and expansions that may never happen or tries to achieve levels of fault tolerance and scalability that are not actually needed.
2) Overgeneralization and claiming a software can do things that are not fully understood also introduces risks. Decoupling should only be done for components that truly need separate development, not just for potential future changes.
3) Start with the simplest possible architecture and refactor as needed when adding new features becomes difficult or impossible with the existing architecture. Frequent refactoring helps keep the system maintainable.
The document summarizes the key points from a presentation on Vaadin 7.1 and the roadmap for Vaadin. It discusses new features in 7.1 like server-initiated events, accessibility improvements, and theme compilation. It outlines the plans for 7.2 including a new responsive grid, application archetype, and CDI integration. The roadmap also mentions updated versions of TouchKit, TestBench, and new components like a spreadsheet. Events in San Francisco and Frankfurt were noted.
The document summarizes updates and new features in Vaadin 7 and the Vaadin roadmap. It discusses features added in Vaadin 7.1 like improved servlet configuration and server-initiated push. It also outlines upcoming features like a client-side Grid component, responsive design support, Vaadin CDI integration, and a new spreadsheet widget. The roadmap slide lists specific versions and target dates for new versions of Vaadin, TouchKit, TestBench, and other planned additions.
Hackathon - Building vaadin add on componentsJoonas Lehtinen
My presentation at Vaadin Hackathon 19-21.4.2013. The presentation outlines all the step of creating a new Vaadin add-on component from design to deployment and publishing.
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.
Vaadin is an open source web framework for building web applications and websites. It began in 2001 and has gone through several major versions including versions 3, 4, 5, 6, and the current version 7. Version 7 features a renewed JavaScript architecture, Sass support, redesigned forms, and built-in view management. The Vaadin framework is used by over 50,000 companies worldwide and has a large community on GitHub.
Migration from vaadin 6 to vaadin 7 devoxx france 2013Joonas Lehtinen
Moving to Vaadin 7 involves migrating from Vaadin 6 to take advantage of new features in Vaadin 7 including a new windowing API, improved field groups and converters, and SASS based themes. The migration involves updating dependencies to Vaadin 7, replacing the Application and Window classes with the UI class, and converting themes to use SASS. Many APIs are backwards compatible but some changes like separate presentation of field groups and converters may require updates to code. The Vaadin documentation provides guides on migration and information on new features in Vaadin 7.
Vaadin 7 is a Java framework for building rich web applications. It allows developers to write UI code in Java and have it rendered as responsive HTML, CSS, and JavaScript that runs in any browser. Key features include rich UI components, separation of server and client code, and support for any JVM language and cloud platform. The framework embraces modern web standards and allows developers to build consumer-grade UX with a business system budget.
This document summarizes the history and architecture of the Vaadin framework. It notes that Vaadin started in 2001 and has gone through several major versions. It describes key architectural aspects of Vaadin including its use of GWT for the client/server divide, support for HTML5, and new windowing APIs. The document outlines upcoming releases and roadmaps for Vaadin, Vaadin Charts, Vaadin TouchKit, and other related projects through April 2013.
This document provides an introduction to Vaadin, including:
1. Vaadin allows building rich web UIs using Java and HTML. It uses a client-server architecture with the UI running on the server and JavaScript/HTML on the client.
2. Key features include rich UI components, support for any JVM language, no browser plugins required, and embracing of Java standards.
3. The document recommends getting started with Vaadin by generating a Maven archetype project in Eclipse.
The document discusses reusable web components and designing them. It provides an agenda that covers what should be designed, technology options like HTML5, Google Web Toolkit and Vaadin, and a Q&A session. It then lists various HTML5 elements like <article>, <audio>, <canvas> and describes them. Finally, it discusses capabilities enabled by HTML5 like drag-and-drop, geolocation, multimedia and more.
Vaadin is a Java-based web application framework that allows building rich client-side web applications using server-side Java and client-side JavaScript. Some key points:
- It uses server-side Java and the GWT compiler to generate lightweight JavaScript widgets for the client-side UI.
- This allows building complex, responsive UIs with a desktop-like experience using standard Java/GWT components on the server side.
- Over 100,000 developers use Vaadin across industries like finance, healthcare, government to build applications for Fortune 500 companies and startups.
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.
The document discusses Vaadin CEO Joonas Lehtinen's thoughts on the roadmap after Vaadin 7. Some of the key points include:
- Vaadin 7 beta 8 is ready and the release candidate is estimated for early December.
- Future versions will focus on adding missing pieces from Vaadin 7 like push support and new themes, and developing client-side APIs for widgets.
- Vaadin 8 is not planned for development in 2013, with focus staying on Vaadin 7.1, 7.2, etc. for bug fixes and new features.
- Other potential ideas discussed include declarative UIs, improved IDE tooling, a book of Vaadin, and CDI integration
The document discusses a client + server hybrid architecture for applications using Vaadin. It involves layers of abstraction between the backend server and frontend web/JavaScript layers, with optional use of RPC, Java-to-JavaScript translation, and JavaScript. The architecture includes a widget on the client connecting via RPC to a component on the server, with state synchronization handled by the state object. Examples of implementations include specific widgets like HourList and views like BarView. Source code for a demo of the hybrid architecture is provided on GitHub.
This document summarizes how to build iPad apps using the Vaadin framework in pure Java. Vaadin allows developing rich web applications using Java server-side components while leveraging HTML and JavaScript on the client-side. It discusses how Vaadin includes an Apple iOS theme and mobile components to build apps for the iPad. Examples are given of building portfolio management apps using Vaadin and its TouchKit. The document outlines getting started with Vaadin development using Maven and provides resources for learning more.
COMPSAC 2024 D&I Panel: Charting a Course for Equity: Strategies for Overcomi...Hironori Washizaki
Hironori Washizaki, "Charting a Course for Equity: Strategies for Overcoming Challenges and Promoting Inclusion in the Metaverse", IEEE COMPSAC 2024 D&I Panel, 2024.
Discover the Power of ONEMONITAR: The Ultimate Mobile Spy App for Android Dev...onemonitarsoftware
Unlock the full potential of mobile monitoring with ONEMONITAR. Our advanced and discreet app offers a comprehensive suite of features, including hidden call recording, real-time GPS tracking, message monitoring, and much more.
Perfect for parents, employers, and anyone needing a reliable solution, ONEMONITAR ensures you stay informed and in control. Explore the key features of ONEMONITAR and see why it’s the trusted choice for Android device monitoring.
Share this infographic to spread the word about the ultimate mobile spy app!
In this talk, we will explore strategies to optimize the success rate of storing and retaining new information. We will discuss scientifically proven ideal learning intervals and content structures. Additionally, we will examine how to create an environment that improves our focus while you remain in the “flow”. Lastly we will also address the influence of AI on learning capabilities.
In the dynamic field of software development, this knowledge will empower you to accelerate your learning curve and support others in their learning journeys.
WhatsApp Tracker - Tracking WhatsApp to Boost Online Safety.pdfonemonitarsoftware
WhatsApp Tracker Software is an effective tool for remotely tracking the target’s WhatsApp activities. It allows users to monitor their loved one’s online behavior to ensure appropriate interactions for responsive device use.
Download this PPTX file and share this information to others.
CViewSurvey Digitech Pvt Ltd that works on a proven C.A.A.G. model.bhatinidhi2001
CViewSurvey is a SaaS-based Web & Mobile application that provides digital transformation to traditional paper surveys and feedback for customer & employee experience, field & market research that helps you evaluate your customer's as well as employee's loyalty.
With our unique C.A.A.G. Collect, Analysis, Act & Grow approach; business & industry’s can create customized surveys on web, publish on app to collect unlimited response & review AI backed real-time data analytics on mobile & tablets anytime, anywhere. Data collected when offline is securely stored in the device, which syncs to the cloud server when connected to any network.
React and Next.js are complementary tools in web development. React, a JavaScript library, specializes in building user interfaces with its component-based architecture and efficient state management. Next.js extends React by providing server-side rendering, routing, and other utilities, making it ideal for building SEO-friendly, high-performance web applications.
Sami provided a beginner-friendly introduction to Amazon Web Services (AWS), covering essential terms, products, and services for cloud deployment. Participants explored AWS' latest Gen AI offerings, making it accessible for those starting their cloud journey or integrating AI into coding practices.
Overview of ERP - Mechlin Technologies.pptxMitchell Marsh
This PowerPoint presentation provides a comprehensive overview of Enterprise Resource Planning (ERP) systems. It covers the fundamental concepts, benefits, and key functionalities of ERP software, illustrating how it integrates various business processes into a unified system. From finance and HR to supply chain and customer relationship management, ERP facilitates efficient data management and decision-making across organizations. Whether you're new to ERP or looking to deepen your understanding, this presentation offers valuable insights into leveraging ERP for business success.
Ansys Mechanical enables you to solve complex structural engineering problems and make better, faster design decisions. With the finite element analysis (FEA) solvers available in the suite, you can customize and automate solutions for your structural mechanics problems and parameterize them to analyze multiple design scenarios. Ansys Mechanical is a dynamic tool that has a complete range of analysis tools.
Are you wondering how to migrate to the Cloud? At the ITB session, we addressed the challenge of managing multiple ColdFusion licenses and AWS EC2 instances. Discover how you can consolidate with just one EC2 instance capable of running over 50 apps using CommandBox ColdFusion. This solution supports both ColdFusion flavors and includes cb-websites, a GoLang binary for managing CommandBox websites.
10. What kind of devices does your app support?
98.1%
3Desktop
browsers
Browsers developers expect to support in 2013
3.5 Browsers to support in 2012
IE 6/7 Safari Opera IE 8
6/7 8
14% 18% 36% 54%
Chrome
9 10
IE 9 IE 10 Firefox
79% 80% 94% 94%
Browsers developers expect to support in 2013
3.5 Browsers to support in 2012
IE 6/7 Safari Opera IE 8
6/7 8
14% 18% 36% 54%
Chrome
9 10
IE 9 IE 10 Firefox
79% 80% 94% 94%
s
your app
support?
25.7%
Phones
36.1%
O
thers2.1%
“Since gw
in
the enterp
explain
why tab
popular than
supp
phones”
Daniel
iPhone
Android
W
P
pplication
UI for
r 98%
of apps
overtaken
the
num
ber
rope.
36.1%
Tablets
“Since
gwt is used
extensi
in
the
enterprise, this m
explain
why tablets
popular than
su
phones”
iPadAndroid
W
indow
s
+
+
75. Timeline
When could you really use web components
With full CSS sandbox (native)
Evergreen browsers (polyfilled)
Old browsers
IE <10, Safari <6, < latest iOS/FF/Chrome/Android
Today Soonish? ∞
78. Elements.registerElement("v-grid", new WCVGrid());
@JsExport
@JsType
public class WCVGrid extends HTMLElement.Prototype implements LifeCycle.Attached {
private Grid<JsArrayMixed> grid = new Grid<>();
@Override
public void attachedCallback() {
HTMLShadow shadow = createShadowRoot();
shadow.appendChild(style);
shadow.appendChild(container);
Panel shadowPanel = wrapAsWidget(container);
shadowPanel.add(grid);
}
@JsProperty
public void setDataSource(JavaScriptObject jso) {
grid.setDataSource(wrapJsoDataSource(jso));
}
}
79. Elements.registerElement("v-grid", new WCVGrid());
@JsExport
@JsType
public class WCVGrid extends HTMLElement.Prototype implements LifeCycle.Attached {
private Grid<JsArrayMixed> grid = new Grid<>();
@Override
public void attachedCallback() {
HTMLShadow shadow = createShadowRoot();
shadow.appendChild(style);
shadow.appendChild(container);
Panel shadowPanel = wrapAsWidget(container);
shadowPanel.add(grid);
}
@JsProperty
public void setDataSource(JavaScriptObject jso) {
grid.setDataSource(wrapJsoDataSource(jso));
}
}
80. Elements.registerElement("v-grid", new WCVGrid());
@JsExport
@JsType
public class WCVGrid extends HTMLElement.Prototype implements LifeCycle.Attached {
private Grid<JsArrayMixed> grid = new Grid<>();
@Override
public void attachedCallback() {
HTMLShadow shadow = createShadowRoot();
shadow.appendChild(style);
shadow.appendChild(container);
Panel shadowPanel = wrapAsWidget(container);
shadowPanel.add(grid);
}
@JsProperty
public void setDataSource(JavaScriptObject jso) {
grid.setDataSource(wrapJsoDataSource(jso));
}
}
81. Elements.registerElement("v-grid", new WCVGrid());
@JsExport
@JsType
public class WCVGrid extends HTMLElement.Prototype implements LifeCycle.Attached {
private Grid<JsArrayMixed> grid = new Grid<>();
@Override
public void attachedCallback() {
HTMLShadow shadow = createShadowRoot();
shadow.appendChild(style);
shadow.appendChild(container);
Panel shadowPanel = wrapAsWidget(container);
shadowPanel.add(grid);
}
@JsProperty
public void setDataSource(JavaScriptObject jso) {
grid.setDataSource(wrapJsoDataSource(jso));
}
}
82. Elements.registerElement("v-grid", new WCVGrid());
@JsExport
@JsType
public class WCVGrid extends HTMLElement.Prototype implements LifeCycle.Attached {
private Grid<JsArrayMixed> grid = new Grid<>();
@Override
public void attachedCallback() {
HTMLShadow shadow = createShadowRoot();
shadow.appendChild(style);
shadow.appendChild(container);
Panel shadowPanel = wrapAsWidget(container);
shadowPanel.add(grid);
}
@JsProperty
public void setDataSource(JavaScriptObject jso) {
grid.setDataSource(wrapJsoDataSource(jso));
}
}
83. Elements.registerElement("v-grid", new WCVGrid());
@JsExport
@JsType
public class WCVGrid extends HTMLElement.Prototype implements LifeCycle.Attached {
private Grid<JsArrayMixed> grid = new Grid<>();
@Override
public void attachedCallback() {
HTMLShadow shadow = createShadowRoot();
shadow.appendChild(style);
shadow.appendChild(container);
Panel shadowPanel = wrapAsWidget(container);
shadowPanel.add(grid);
}
@JsProperty
public void setDataSource(JavaScriptObject jso) {
grid.setDataSource(wrapJsoDataSource(jso));
}
}
84. <v-grid>
Sass API for theme engine
<v-component> / JS API
GWT
API
Java Server
Automatic
communication
API
AngularJS
API
85. Autogenerated
<v-grid>
Sass API for theme engine
<v-component> / JS API
AngularJS GWT
API
Java Server
Automatic
communication
API
Polymer
JavaScript
GWT Element
Java
GWT Element
GWT Widget
Java
API
97. vaadin-widgets-7.4.0.jar
• Grid Widget API
• Stable and supported
• Wide browser support
• IE8+
• All the modern ones: FF, Chrome, iOS, Android, …
�� Example: https://github.com/Artur-/grid-gwt
Get from http://vaadin.com/downloadbeta or Maven