The document discusses Google Web Toolkit (GWT), a development toolkit that allows developers to write client-side applications in Java and compile them to optimized JavaScript that runs across browsers, providing features like Ajax functionality, browser compatibility, and optimizations for both developers and users. GWT uses generators, translators, and linkers to compile Java code into JavaScript that can run directly in web browsers.
The document discusses Google Web Toolkit (GWT), a development toolkit that allows developers to write client-side applications in Java and have their code compiled into optimized JavaScript that runs across browsers. It provides an overview of GWT, demonstrates its capabilities, and discusses how it optimizes applications for both developers and users. GWT aims to simplify Ajax development, improve cross-browser portability, and increase application performance.
Here are the key things GWT's generators do to enable RPCs:
1. Generate serialization/deserialization code:
- The generator analyzes the service interface and generates code to serialize/deserialize requests and responses to/from JSON or other formats.
2. Generate client-side proxy classes:
- Proxy classes handle calling the service and mapping requests/responses to Java objects on the client.
3. Handle asynchronous callbacks:
- The proxy implements callbacks so the client code receives responses asynchronously without blocking.
4. Handle cross-domain requests:
- GWT handles any cross-domain issues behind the scenes via techniques like JSONP.
So in summary, the generators automate all the boiler
Hybrid Apps (Native + Web) using WebKitAriya Hidayat
In term of innovations and mobile availability, WebKit is known to be the premier web rendering engine with the leading support for web standards such as HTML5, CSS3, and SVG. On MeeGo platform, WebKit can be leveraged easily via the use QtWebKit module which combines powerful WebKit features with the ease of use of Qt. The ground of developing applications using native technologies has been much explored, however there are still confusions, myths and misunderstanding as to what can be achieved with web technologies and hybrid native-web approach. This talk will highlight several tools and best practices in developing and testing good looking, feature-rich, and hardware-accelerated applications using web technologies targeting MeeGo platform in particular.
This document discusses best practices in Qt Quick/QML. It covers the building blocks of QML like QObject and QQuickItem which inherit from QObject. It describes properties, signals, slots and introspection capabilities. Anchors provide a declarative way to lay out items by attaching them to parent and sibling items, improving performance over dead reckoning layouts. The document promotes using anchors and bindings over procedural JavaScript for layout where possible.
Gradle is a flexible general purpose build system with a build-by-convention framework a la Maven on top. It uses Apache Ivy under the hood for its dependency management. Its build scripts are written in Groovy.
The document discusses best practices for managing memory in Android applications to avoid memory leaks and performance issues. It provides 3 key points:
1. Be aware of how memory is managed in Android and the garbage collection process. Allocations during critical parts like onDraw can cause stutters.
2. Learn techniques to detect memory issues like using LeakCanary, tracking allocations, and dumping the heap. Understanding memory profiles of an app is important.
3. Apply best practices like avoiding long-lived references to activities, using WeakReferences for inner classes, and cleaning up resources on stop to prevent leaks and improve performance. Memory management is important for smooth experiences.
This webinar presents the official set of bindings to use Qt's API in your Python application. Using real examples, we will not only implement a beautiful UI, we'll illustrate how it interacts with your regular Python business logic.
The document discusses Google Web Toolkit (GWT), a development toolkit that allows developers to write client-side applications in Java and have their code compiled into optimized JavaScript that runs across browsers. It provides an overview of GWT, demonstrates its capabilities, and discusses how it optimizes applications for both developers and users. GWT aims to simplify Ajax development, improve cross-browser portability, and increase application performance.
Here are the key things GWT's generators do to enable RPCs:
1. Generate serialization/deserialization code:
- The generator analyzes the service interface and generates code to serialize/deserialize requests and responses to/from JSON or other formats.
2. Generate client-side proxy classes:
- Proxy classes handle calling the service and mapping requests/responses to Java objects on the client.
3. Handle asynchronous callbacks:
- The proxy implements callbacks so the client code receives responses asynchronously without blocking.
4. Handle cross-domain requests:
- GWT handles any cross-domain issues behind the scenes via techniques like JSONP.
So in summary, the generators automate all the boiler
Hybrid Apps (Native + Web) using WebKitAriya Hidayat
In term of innovations and mobile availability, WebKit is known to be the premier web rendering engine with the leading support for web standards such as HTML5, CSS3, and SVG. On MeeGo platform, WebKit can be leveraged easily via the use QtWebKit module which combines powerful WebKit features with the ease of use of Qt. The ground of developing applications using native technologies has been much explored, however there are still confusions, myths and misunderstanding as to what can be achieved with web technologies and hybrid native-web approach. This talk will highlight several tools and best practices in developing and testing good looking, feature-rich, and hardware-accelerated applications using web technologies targeting MeeGo platform in particular.
This document discusses best practices in Qt Quick/QML. It covers the building blocks of QML like QObject and QQuickItem which inherit from QObject. It describes properties, signals, slots and introspection capabilities. Anchors provide a declarative way to lay out items by attaching them to parent and sibling items, improving performance over dead reckoning layouts. The document promotes using anchors and bindings over procedural JavaScript for layout where possible.
Gradle is a flexible general purpose build system with a build-by-convention framework a la Maven on top. It uses Apache Ivy under the hood for its dependency management. Its build scripts are written in Groovy.
The document discusses best practices for managing memory in Android applications to avoid memory leaks and performance issues. It provides 3 key points:
1. Be aware of how memory is managed in Android and the garbage collection process. Allocations during critical parts like onDraw can cause stutters.
2. Learn techniques to detect memory issues like using LeakCanary, tracking allocations, and dumping the heap. Understanding memory profiles of an app is important.
3. Apply best practices like avoiding long-lived references to activities, using WeakReferences for inner classes, and cleaning up resources on stop to prevent leaks and improve performance. Memory management is important for smooth experiences.
This webinar presents the official set of bindings to use Qt's API in your Python application. Using real examples, we will not only implement a beautiful UI, we'll illustrate how it interacts with your regular Python business logic.
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for part 3 of our 4 part webinar series where we explore the best of QML for mobile, embedded and desktop.
Part 3 will cover:
C++ / QML Integration
Reusing Existing C++ Code
The JVM JIT compiler and deoptimizer are triggered under certain conditions like method invocation counts, changes in program behavior, and hot spots. The JIT initially compiles code to generate fast machine instructions while the deoptimizer reverts back to interpreted execution if needed.
This document provides an introduction to CMake, including:
- CMake is a cross-platform build system that sits on top of native build systems and is funded by KitWare.
- Features include support for in-place and out-of-place builds, cross-compilation, executables, libraries, and generated files.
- Examples demonstrate basic "Hello World" CMake usage as well as more complex examples incorporating libraries, installation, and Qt support.
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for this webinar to explore the best of QML for mobile, embedded and desktop.
Part III will cover:
- C++ Backends
- Reusing existing code
- Creating QML Modules
Qt and QML performance tips & tricks for Qt 4.7Pasi Kellokoski
The document provides performance tips for Qt/QML applications. It recommends:
1. Using C++ rather than JavaScript for business logic and long-running operations to avoid blocking the UI.
2. Loading content dynamically with Loaders and partitioning the UI into logical components to improve startup speed.
3. Caching images at their native size and resolution, loading images asynchronously, and avoiding unnecessary resizing or compositing of images to reduce memory usage and improve performance of visual elements.
4. Optimizing data models and use of cache buffers to improve the performance of scrolling in lists and grids.
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us as we explore the best of QML for mobile, embedded and desktop.
Part I will cover:
- Building Blocks of QML
- Qt Properties
- Declarative Code
The document discusses localization and internationalization with Qt. It covers:
- What internationalization and localization are
- How to localize user interface strings in Qt using functions like tr()
- Managing translations with Qt Linguist, including generating .ts files and loading .qm files at runtime
- Additional localization considerations for Qt Quick/QML apps and advanced topics like cultural differences
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for part 2 of our 4 part webinar series where we explore the best of QML for mobile, embedded and desktop.
Part 2 will cover:
Creating New Items
States and Transitions
Dynamic Creation of Items
"Xapi-lang For declarative code generation" By James NelsonGWTcon
Xapi-lang is a Java parser enhanced with an XML-like syntax that can be used for code generation, templating, and creating domain-specific languages. It works by parsing code into an abstract syntax tree and then applying visitors to analyze and transform the AST to produce output. Examples shown include class templating, API generation from templates, and UI component generation. The document also discusses best practices for code generation and outlines plans for rebuilding the GWT toolchain to support GWT 3 and J2CL. It promotes a new company, Vertispan, for GWT support and consulting and introduces another project called We The Internet for building tools to improve political systems using distributed democracy.
Serving QML applications over the networkJeremy Lainé
Qt Quick's support for network transparency makes it possible to serve an application's user interface and logic over the network. This allows application developers to adopt fast web-like release cycles, but it does require some planning ahead. The presentation will highlight some benefits of serving QML applications over the network, give an overview of QML's network transparency support and illustrate how to build and serve QML applications. The presentation will also address some of the challenges encountered in a real world application deployment.
The document provides an overview of principles and techniques for effective engineering in C++, including:
- Focusing on high-leverage activities that maximize impact per unit of time such as optimizing for learning and iteration speed.
- Leveraging third-party libraries, design patterns like Factory and Observer, and C++11/14 features.
- Using tools like Clang, CMake, GTest and GMock for testing, AddressSanitizer and ThreadSanitizer for debugging, and GPerfTools and Docker for profiling and testing across environments.
In this webinar (Part IV) we explore how to implement UI and UI behavior with traditional widgets as opposed to QML. As we create a simple widgets applications we will point out the differences with Qt Quick and give rules of thumb of which one to use for a particular project.
The document discusses using Grails for developing an enterprise telecom application. It describes the application and deployment environment, how Grails improved development productivity, and key plugins and techniques used. Grails enabled faster development through GORM and scaffolding. AST transformations and custom components further improved code readability and maintainability. While there were frustrations with Grails, overall the developers found Groovy and Grails empowering and were enthusiastic about the technology.
Gradle build tool that rocks with DSL JavaOne India 4th May 2012Rajmahendra Hegde
For the long time, we have used various build tools to package applications for new software releases or applying patches to existing applications etc. dependency management, version controlling, scalability, flexibility, single-multiple projects sup portability are some of the key areas that drove the selection of a build tool, This session focuses on Gradle as a successful build tool and looks into all the above areas and uses Groovy as a DSL. We will also look into how easy it is to use Gradle as compared to other open source build tools.
Photos: https://plus.google.com/u/0/photos/105295086916869617504/albums/5739617166453582993
Gradle build tool that rocks with DSL By Rajmahendra Hegde at JavaOne Hyderabad, India on 4th May 2012
Hybrid development using Qt WebKit allows developers to embed a fully functional web browser inside a Qt application. Qt WebKit provides a bridge between Qt and the WebKit rendering engine, allowing developers to load web content, manipulate web pages, and integrate their applications with web services. Developers can inject QObjects into web pages to expose slots, properties, and signals to JavaScript, and can also call JavaScript functions and extract their return values from the C++ side.
Lockless Producer Consumer Threads: Asynchronous Communications Made EasyICS
In ICS’ latest technical webinar Justin Noel will teach you how to leverage Qt's cross thread communications systems to marshall data to and from communications threads using QThreads (or threads owned by third party libraries.) He’ll show you that by using the lockless producer consumer pattern you can write efficient and easy to read code without needing to add mutexes to your data structures, important because data read by QML bindings needs to be as quick as possible to avoid dropping frames. Don’t miss it!
QVariant, QObject — Qt's not just for GUI developmentICS
This document summarizes a webinar on Qt's object model. It discusses how Qt's classes can be divided into identity types like QObject that derive from C++ and extend it with features using a meta-object system, and value types like QVariant that use copy-on-write. It covers how QObject is the heart of Qt's object model and includes features like memory management, object properties, introspection, signals and slots, and event handling. It also discusses QVariant's role as a union for common value types, and how to make custom classes use QVariants and properties.
Android android + app engine a developer's dream combinationChris Ramsdale
The document discusses how the Google Plugin for Eclipse version 2.4 makes it easy for developers to build Android applications that connect to Google App Engine. Some key points covered include how App Engine provides cost-effective and scalable hosting, built-in security and user authentication via Google accounts, and an easy development experience through features like local testing and push-button deployment. The plugin now includes support for developing both App Engine and Android applications in a single integrated environment. An example task management application demonstrates how to architect an app that connects an Android client to App Engine in the cloud.
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for part 3 of our 4 part webinar series where we explore the best of QML for mobile, embedded and desktop.
Part 3 will cover:
C++ / QML Integration
Reusing Existing C++ Code
The JVM JIT compiler and deoptimizer are triggered under certain conditions like method invocation counts, changes in program behavior, and hot spots. The JIT initially compiles code to generate fast machine instructions while the deoptimizer reverts back to interpreted execution if needed.
This document provides an introduction to CMake, including:
- CMake is a cross-platform build system that sits on top of native build systems and is funded by KitWare.
- Features include support for in-place and out-of-place builds, cross-compilation, executables, libraries, and generated files.
- Examples demonstrate basic "Hello World" CMake usage as well as more complex examples incorporating libraries, installation, and Qt support.
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for this webinar to explore the best of QML for mobile, embedded and desktop.
Part III will cover:
- C++ Backends
- Reusing existing code
- Creating QML Modules
Qt and QML performance tips & tricks for Qt 4.7Pasi Kellokoski
The document provides performance tips for Qt/QML applications. It recommends:
1. Using C++ rather than JavaScript for business logic and long-running operations to avoid blocking the UI.
2. Loading content dynamically with Loaders and partitioning the UI into logical components to improve startup speed.
3. Caching images at their native size and resolution, loading images asynchronously, and avoiding unnecessary resizing or compositing of images to reduce memory usage and improve performance of visual elements.
4. Optimizing data models and use of cache buffers to improve the performance of scrolling in lists and grids.
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us as we explore the best of QML for mobile, embedded and desktop.
Part I will cover:
- Building Blocks of QML
- Qt Properties
- Declarative Code
The document discusses localization and internationalization with Qt. It covers:
- What internationalization and localization are
- How to localize user interface strings in Qt using functions like tr()
- Managing translations with Qt Linguist, including generating .ts files and loading .qm files at runtime
- Additional localization considerations for Qt Quick/QML apps and advanced topics like cultural differences
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for part 2 of our 4 part webinar series where we explore the best of QML for mobile, embedded and desktop.
Part 2 will cover:
Creating New Items
States and Transitions
Dynamic Creation of Items
"Xapi-lang For declarative code generation" By James NelsonGWTcon
Xapi-lang is a Java parser enhanced with an XML-like syntax that can be used for code generation, templating, and creating domain-specific languages. It works by parsing code into an abstract syntax tree and then applying visitors to analyze and transform the AST to produce output. Examples shown include class templating, API generation from templates, and UI component generation. The document also discusses best practices for code generation and outlines plans for rebuilding the GWT toolchain to support GWT 3 and J2CL. It promotes a new company, Vertispan, for GWT support and consulting and introduces another project called We The Internet for building tools to improve political systems using distributed democracy.
Serving QML applications over the networkJeremy Lainé
Qt Quick's support for network transparency makes it possible to serve an application's user interface and logic over the network. This allows application developers to adopt fast web-like release cycles, but it does require some planning ahead. The presentation will highlight some benefits of serving QML applications over the network, give an overview of QML's network transparency support and illustrate how to build and serve QML applications. The presentation will also address some of the challenges encountered in a real world application deployment.
The document provides an overview of principles and techniques for effective engineering in C++, including:
- Focusing on high-leverage activities that maximize impact per unit of time such as optimizing for learning and iteration speed.
- Leveraging third-party libraries, design patterns like Factory and Observer, and C++11/14 features.
- Using tools like Clang, CMake, GTest and GMock for testing, AddressSanitizer and ThreadSanitizer for debugging, and GPerfTools and Docker for profiling and testing across environments.
In this webinar (Part IV) we explore how to implement UI and UI behavior with traditional widgets as opposed to QML. As we create a simple widgets applications we will point out the differences with Qt Quick and give rules of thumb of which one to use for a particular project.
The document discusses using Grails for developing an enterprise telecom application. It describes the application and deployment environment, how Grails improved development productivity, and key plugins and techniques used. Grails enabled faster development through GORM and scaffolding. AST transformations and custom components further improved code readability and maintainability. While there were frustrations with Grails, overall the developers found Groovy and Grails empowering and were enthusiastic about the technology.
Gradle build tool that rocks with DSL JavaOne India 4th May 2012Rajmahendra Hegde
For the long time, we have used various build tools to package applications for new software releases or applying patches to existing applications etc. dependency management, version controlling, scalability, flexibility, single-multiple projects sup portability are some of the key areas that drove the selection of a build tool, This session focuses on Gradle as a successful build tool and looks into all the above areas and uses Groovy as a DSL. We will also look into how easy it is to use Gradle as compared to other open source build tools.
Photos: https://plus.google.com/u/0/photos/105295086916869617504/albums/5739617166453582993
Gradle build tool that rocks with DSL By Rajmahendra Hegde at JavaOne Hyderabad, India on 4th May 2012
Hybrid development using Qt WebKit allows developers to embed a fully functional web browser inside a Qt application. Qt WebKit provides a bridge between Qt and the WebKit rendering engine, allowing developers to load web content, manipulate web pages, and integrate their applications with web services. Developers can inject QObjects into web pages to expose slots, properties, and signals to JavaScript, and can also call JavaScript functions and extract their return values from the C++ side.
Lockless Producer Consumer Threads: Asynchronous Communications Made EasyICS
In ICS’ latest technical webinar Justin Noel will teach you how to leverage Qt's cross thread communications systems to marshall data to and from communications threads using QThreads (or threads owned by third party libraries.) He’ll show you that by using the lockless producer consumer pattern you can write efficient and easy to read code without needing to add mutexes to your data structures, important because data read by QML bindings needs to be as quick as possible to avoid dropping frames. Don’t miss it!
QVariant, QObject — Qt's not just for GUI developmentICS
This document summarizes a webinar on Qt's object model. It discusses how Qt's classes can be divided into identity types like QObject that derive from C++ and extend it with features using a meta-object system, and value types like QVariant that use copy-on-write. It covers how QObject is the heart of Qt's object model and includes features like memory management, object properties, introspection, signals and slots, and event handling. It also discusses QVariant's role as a union for common value types, and how to make custom classes use QVariants and properties.
Android android + app engine a developer's dream combinationChris Ramsdale
The document discusses how the Google Plugin for Eclipse version 2.4 makes it easy for developers to build Android applications that connect to Google App Engine. Some key points covered include how App Engine provides cost-effective and scalable hosting, built-in security and user authentication via Google accounts, and an easy development experience through features like local testing and push-button deployment. The plugin now includes support for developing both App Engine and Android applications in a single integrated environment. An example task management application demonstrates how to architect an app that connects an Android client to App Engine in the cloud.
Visit to El Porton Verde EcoLodge in Managua, Nicaraguawebtrainer
Miranda and Mike took a trip to Nicaragua from December 30, 2008 to January 18, 2009. They stayed at a house they own called El Porton Verde, or "la finca", which is still being renovated. During their trip, they relaxed with family, saw new volcanoes, went surfing at different beaches, and took day trips within Nicaragua, including one to Chinandega. They celebrated their 4th wedding anniversary during the trip and enjoyed the scenery and activities at their property and around Nicaragua before returning home.
El documento presenta un juego en el que los participantes deben pensar en un número de dos cifras, restarle la suma de sus cifras y encontrar el símbolo correspondiente a ese resultado en una tabla provista. Luego deben preguntarle a una bruja cuál es ese símbolo para verificar si ella lo adivina correctamente. El texto guía a los jugadores a través de varias rondas del juego.
Este documento desea a los amigos de la Web 2.0 una Feliz Navidad y un próspero Año Nuevo, y les regala amistad, sonrisas y grandes sueños. Desea que encuentren el camino de la felicidad y tengan salud para disfrutarlo.
The document outlines key terms related to audience theory such as active, passive, and subversive audiences. It discusses theories by David Gauntlett and Richard Sennett that suggest audiences have become more active. Students are tasked with planning an essay discussing the advantages and disadvantages for audiences in the digital age using terms around production, distribution, consumption, and key theorists and technologies.
The document discusses the benefits of exercise for mental health. Regular physical activity can help reduce anxiety and depression and improve mood and cognitive function. Exercise causes chemical changes in the brain that may help protect against mental illness and improve symptoms.
The document discusses how the Google Plugin for Eclipse version 2.4 makes it easy for developers to build Android applications that connect to Google App Engine. It notes that App Engine provides cost-effective scalability, security through Google accounts, and ease of use. The plugin allows local debugging of Android apps, integrated deployment to App Engine, and access to Google APIs from a GWT-based web or Android interface. It announces new support in version 2.4 for building Android apps that seamlessly integrate App Engine and Cloud Messaging for push notifications.
The document provides guidance for writing a timed essay on the topic of the proliferation of hardware and content in the music industry and its significance for institutions and audiences. It includes potential points to discuss such as different hardware platforms, content sources, examples of convergence technology, and their significance for institutions like record labels and audiences. Students are asked to discuss this topic in 3 sentences or less based on the source material and suggested discussion points.
Este documento desea a los amigos de la Web 2.0 una Feliz Navidad y un próspero Año Nuevo, y les regala amistad, sonrisas y grandes sueños. Desea que encuentren el camino de la felicidad y tengan salud para disfrutarlo.
Prezentarea Parcului National Cozia pentru scolile din comunitatile din jurul parcului, cu ocazia selectionarii participantilor la o tabara Ranger Junior.
How to build business web apps using GWT and Spring ToolsChris Ramsdale
The document discusses the benefits of exercise for mental health. Regular physical activity can help reduce anxiety and depression and improve mood and cognitive functioning. Exercise causes chemical changes in the brain that may help protect against mental illness and improve symptoms.
Acest ghid se doreşte a fi un instrument practic pentru administratorii şi custozii de arii protejate în conceperea şi realizarea de poteci tematice.
Scopul ghidului este de a oferi câteva linii îndrumătoare privind o modalitate structurată de concepere şi realizare a unei poteci tematice, ca instument de educaţie informală pentru mediu, în cadrul ariilor protejate.
Prin exemplele date dorim să ilustrăm cum se poate ajunge la rezultate bune, plecând de la informaţia ştiinţifică, care prin creativitate şi putere de concentrare a esenţei poate ajunge să fie o informaţie uşor de reţinut de vizitator, captivantă şi motivantă pentru activităţi viitoare.
Hybrid Apps (Native + Web) using WebKitAriya Hidayat
In term of innovations and mobile availability, WebKit is known to be the premier web rendering engine with the leading support for web standards such as HTML5, CSS3, and SVG. On MeeGo platform, WebKit can be leveraged easily via the use QtWebKit module which combines powerful WebKit features with the ease of use of Qt. The ground of developing applications using native technologies has been much explored, however there are still confusions, myths and misunderstanding as to what can be achieved with web technologies and hybrid native-web approach. This talk will highlight several tools and best practices in developing and testing good looking, feature-rich, and hardware-accelerated applications using web technologies targeting MeeGo platform in particular.
Hybrid Apps (Native + Web) via QtWebKitAriya Hidayat
This document discusses hybrid apps that combine native and web technologies using QtWebKit. It provides an overview of QtWebKit and how it can be used to embed web content in native apps. It describes various tools, technologies and frameworks that can be used to build hybrid apps, including JavaScript, CSS, Canvas, WebGL, and tools for debugging, testing, and designing hybrid apps. It concludes that web technologies are advancing rapidly and hybrid approaches can help migration, while tools still need to catch up to support building high quality hybrid apps.
JVM Mechanics: When Does the JVM JIT & Deoptimize?Doug Hawkins
HotSpot promises to do the "right" thing for us by identifying our hot code and compiling "just-in-time", but how does HotSpot make those decisions?
This presentation aims to detail how HotSpot makes those decisions and how it corrects its mistakes through a series of demos that you run yourself.
This document discusses using various technologies on Google App Engine including JIQL, GaeVFS, RESTlets, scheduled tasks, JRuby on Rails, task queues, XMPP, and Clojure. JIQL emulates a relational database on App Engine's Bigtable datastore. GaeVFS provides a virtual filesystem on Bigtable. RESTlets make RESTful web services easy to implement in Java on App Engine. Scheduled tasks allow for background processing via cron jobs. JRuby on Rails provides a way to run Ruby on Rails applications on App Engine. Task queues allow for asynchronous background processing. XMPP enables instant messaging and peer-to-peer applications. Clojure can also be used
In this session, see Google Web Toolkit used in exotic and creative ways to solve interesting engineering problems, from authoring OpenSocial apps that run as both Web gadgets and native Android applications, to developing Adobe AIR applications using GWT, compiling CSS selectors to Javascript at compile time, running multithreaded code with GWT and Gears workers, or exporting GWT libraries for JavaScript users. Learn the secrets of writing "faster than possible" GWT code, how to use Generators and Linkers in harmony, and make seamless procedure calls from GWT code to other environments like Flash, Gears, or Android.
SF JUG - GWT Can Help You Create Amazing Apps - 2009-10-13Fred Sauer
This document summarizes a presentation about Google Web Toolkit (GWT). It discusses how GWT can help developers create apps by allowing them to use Java to build AJAX apps that run on any modern browser, highlights of GWT features like widgets, libraries, compiler optimizations for performance and code size, and resources for learning more about GWT.
Writing code is cool, but see it generating automatically is even cooler! This talk will be a case study about possibilities of Annotation Preprocessing in Java development. Let's look into popular libraries and frameworks that are using Annotation Preprocessing (like Lombok, Dagger 2, Retrofit, MapStruct), talk about it pros and cons compared with Reflection / Runtime Code Generation and discuss how you can create your own library that will generate boilerplate code at compile time.
The document discusses high performance websites, introducing xDebug profiling, Kcachegrind, and JMeter. It provides instructions for installing necessary software on a virtual machine, including Apache, xDebug, JMeter, and Kcachegrind. The document then demonstrates how to use these tools to optimize website performance, including profiling a sample extension in TYPO3, identifying optimization opportunities, and implementing caching. Finally, it shows how to test website performance using JMeter, including building test plans, recording tests, distributed testing on Amazon EC2, and analyzing results.
GraalVM allows building native applications from Java and other JVM languages. It includes a new just-in-time compiler called Graal and the Truffle framework for building language interpreters. GraalVM also includes Sulong, which allows running LLVM-based languages on the JVM. The presenter discussed using GraalVM to build a native executable for a Zookeeper CLI tool called zkstat from Java code using techniques like ahead-of-time compilation with SubstrateVM, configuring reflection, and building a Docker image for distribution.
The document summarizes the ContactOffice company's decision to reengineer its web interface using the Google Web Toolkit (GWT) framework. It discusses why GWT was chosen, the development process, and some of the key enhancements developed for ContactOffice using GWT, such as drag and drop, property pages for dialog boxes, and integration of legacy pages. It also provides an overview of the ContactOffice application and some before and after examples of the new GWT-based interface.
Cassandra Summit 2014: Highly Scalable Web Application in the Cloud with Cass...DataStax Academy
Presenters, L
Putting together a cloud based web application that allows end users to upload, encode, manage and distribute video media files is not a difficult task these days. Especially with the number of related frameworks and services available, ready to be used or consumed. The situation gets more complex when the expected traffic is in the millions-of-users range, globally distributed, and requiring detailed monitoring for usage. Using this scenario, in this session you will learn how to use the recently updated Datastax C# Cassandra driver, how to deploy a multi-datacenter Cassandra cluster using the Microsoft Azure platform that can be accessed from different programming languages, and how to leverage existing cloud services to perform some of the tasks associated with this use case.
This is a presentation on Google Web Toolkit given at Devfest 2009 in Buenos Aires Argentina on Nov 17, 2009 by Google Developer Advocate, Chris Schalk
QtWebKit is a web browser engine that can be used to embed web content in applications. It is based on the WebKit open source project, which powers browsers like Safari and Chrome. QtWebKit provides APIs to display web pages, run JavaScript, and integrate web content with native applications. It supports features like SVG, CSS3 animations, and device access. QtWebKit is widely used due to its cross-platform support, extensive test suite, and active open source community.
The document discusses best practices for building applications with Google Web Toolkit (GWT) using the Model-View-Presenter (MVP) pattern, including defining display interfaces, handling events through presenters rather than views, and leveraging frameworks like gwt-presenter and gwt-dispatch for improved code organization and asynchronous communication with servers. It also provides an overview of tools and techniques for debugging, dependency injection, animations and resources for further learning GWT development.
How to lock a Python in a cage? Managing Python environment inside an R projectWLOG Solutions
Presentation from a workshop delivered by Piotr Chaberski during PyData Warsaw Meetup on Feb. 06, 2018.
Imagine that you are developing a project using R and your big corporate customer, after weeks of processing requests to establish open-source analytical environment, finally managed to install R on their production machines. Now you realized, that it would be nice to use some Python library in your solution...
How would you tell the client to switch to Python for a while?
The document discusses RenderScript on LLVM. It describes RenderScript as a way to perform 3D rendering and compute tasks portably and with high performance on Android. It outlines the main components: an offline compiler that optimizes scripts, an online JIT compiler, and a runtime library. It provides an example of using RenderScript to convert an image to grayscale and discusses how scripts are compiled and executed to provide fast launch times.
David Bosschaert & Carsten Ziegelar - Adobe
"The OSGi platform powering AEM provides a dynamic module system and enables component oriented development. Besides serving the as foundation for AEM, there are benefits for application developers.
This talk outlines the ease of use of OSGi in application code and shows how to master development tasks by using the right APIs and tools. Learn about the latest in component development, asynchronous processing, configuration management and deploying your application code in larger modules, so-called subsystems. A subsystem allows to package a set of bundles and configurations. The subsystem can run isolated from other bundles or other applications.
Learn how to leverage the latest OSGi tech for your own projects. All of the functionality discussed works directly with in AEM 6.1, GA now.
Make the most of the power of OSGi.
This talk (delivered at QConLondon 2016) covers the evolution of Coursera's nearline architecture, delves into our latest generation system, and then covers the flagship application of the architecture (evaluating programming assignments).
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024Neo4j
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
Infrastructure Challenges in Scaling RAG with Custom AI modelsZilliz
Building Retrieval-Augmented Generation (RAG) systems with open-source and custom AI models is a complex task. This talk explores the challenges in productionizing RAG systems, including retrieval performance, response synthesis, and evaluation. We’ll discuss how to leverage open-source models like text embeddings, language models, and custom fine-tuned models to enhance RAG performance. Additionally, we’ll cover how BentoML can help orchestrate and scale these AI components efficiently, ensuring seamless deployment and management of RAG systems in the cloud.
Full-RAG: A modern architecture for hyper-personalizationZilliz
Mike Del Balso, CEO & Co-Founder at Tecton, presents "Full RAG," a novel approach to AI recommendation systems, aiming to push beyond the limitations of traditional models through a deep integration of contextual insights and real-time data, leveraging the Retrieval-Augmented Generation architecture. This talk will outline Full RAG's potential to significantly enhance personalization, address engineering challenges such as data management and model training, and introduce data enrichment with reranking as a key solution. Attendees will gain crucial insights into the importance of hyperpersonalization in AI, the capabilities of Full RAG for advanced personalization, and strategies for managing complex data integrations for deploying cutting-edge AI solutions.
GraphSummit Singapore | The Future of Agility: Supercharging Digital Transfor...Neo4j
Leonard Jayamohan, Partner & Generative AI Lead, Deloitte
This keynote will reveal how Deloitte leverages Neo4j’s graph power for groundbreaking digital twin solutions, achieving a staggering 100x performance boost. Discover the essential role knowledge graphs play in successful generative AI implementations. Plus, get an exclusive look at an innovative Neo4j + Generative AI solution Deloitte is developing in-house.
AI 101: An Introduction to the Basics and Impact of Artificial IntelligenceIndexBug
Imagine a world where machines not only perform tasks but also learn, adapt, and make decisions. This is the promise of Artificial Intelligence (AI), a technology that's not just enhancing our lives but revolutionizing entire industries.
HCL Notes und Domino Lizenzkostenreduzierung in der Welt von DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-und-domino-lizenzkostenreduzierung-in-der-welt-von-dlau/
DLAU und die Lizenzen nach dem CCB- und CCX-Modell sind für viele in der HCL-Community seit letztem Jahr ein heißes Thema. Als Notes- oder Domino-Kunde haben Sie vielleicht mit unerwartet hohen Benutzerzahlen und Lizenzgebühren zu kämpfen. Sie fragen sich vielleicht, wie diese neue Art der Lizenzierung funktioniert und welchen Nutzen sie Ihnen bringt. Vor allem wollen Sie sicherlich Ihr Budget einhalten und Kosten sparen, wo immer möglich. Das verstehen wir und wir möchten Ihnen dabei helfen!
Wir erklären Ihnen, wie Sie häufige Konfigurationsprobleme lösen können, die dazu führen können, dass mehr Benutzer gezählt werden als nötig, und wie Sie überflüssige oder ungenutzte Konten identifizieren und entfernen können, um Geld zu sparen. Es gibt auch einige Ansätze, die zu unnötigen Ausgaben führen können, z. B. wenn ein Personendokument anstelle eines Mail-Ins für geteilte Mailboxen verwendet wird. Wir zeigen Ihnen solche Fälle und deren Lösungen. Und natürlich erklären wir Ihnen das neue Lizenzmodell.
Nehmen Sie an diesem Webinar teil, bei dem HCL-Ambassador Marc Thomas und Gastredner Franz Walder Ihnen diese neue Welt näherbringen. Es vermittelt Ihnen die Tools und das Know-how, um den Überblick zu bewahren. Sie werden in der Lage sein, Ihre Kosten durch eine optimierte Domino-Konfiguration zu reduzieren und auch in Zukunft gering zu halten.
Diese Themen werden behandelt
- Reduzierung der Lizenzkosten durch Auffinden und Beheben von Fehlkonfigurationen und überflüssigen Konten
- Wie funktionieren CCB- und CCX-Lizenzen wirklich?
- Verstehen des DLAU-Tools und wie man es am besten nutzt
- Tipps für häufige Problembereiche, wie z. B. Team-Postfächer, Funktions-/Testbenutzer usw.
- Praxisbeispiele und Best Practices zum sofortigen Umsetzen
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/building-and-scaling-ai-applications-with-the-nx-ai-manager-a-presentation-from-network-optix/
Robin van Emden, Senior Director of Data Science at Network Optix, presents the “Building and Scaling AI Applications with the Nx AI Manager,” tutorial at the May 2024 Embedded Vision Summit.
In this presentation, van Emden covers the basics of scaling edge AI solutions using the Nx tool kit. He emphasizes the process of developing AI models and deploying them globally. He also showcases the conversion of AI models and the creation of effective edge AI pipelines, with a focus on pre-processing, model conversion, selecting the appropriate inference engine for the target hardware and post-processing.
van Emden shows how Nx can simplify the developer’s life and facilitate a rapid transition from concept to production-ready applications.He provides valuable insights into developing scalable and efficient edge AI solutions, with a strong focus on practical implementation.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
Pushing the limits of ePRTC: 100ns holdover for 100 daysAdtran
At WSTS 2024, Alon Stern explored the topic of parametric holdover and explained how recent research findings can be implemented in real-world PNT networks to achieve 100 nanoseconds of accuracy for up to 100 days.
Unlocking Productivity: Leveraging the Potential of Copilot in Microsoft 365, a presentation by Christoforos Vlachos, Senior Solutions Manager – Modern Workplace, Uni Systems
TrustArc Webinar - 2024 Global Privacy SurveyTrustArc
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
1. Google Web Toolkit
Building Web Apps Sanely
Chris Ramsdale
Developer Relations, Google
2. Between us and lunch
• Overview
• Deeper dive
• Optimizations for developers
• Optimizations for users
• Intro to GWT & MVP
3. From 25,000 feet
• Development toolkit, not a framework
• Code in Java, run as Javascript
• One codebase, any browser
• Makes Ajax a piece of cake...and faster
• Used within many Google products, including
Google Wave and Ad Words
4. The GWT Family
GWT SDK Google Plugin Speed Tracer
For Eclipse
9. Focus on the users
Our users - developers
• Leverage existing IDEs and tools
• Minimize refresh time between codes changes
• Automate where possible
Your users - customers
• Minimize startup time
• Make it a comfortable experience
• Allow them to select the browser
12. Different Goals
Developers Customers
• Next killer feature • Make it fast
• Making it look good • ...oh, and don’t charge
my credit card twice
• Code refactoring
13. Different Goals
Developers Customers
• Next killer feature • Make it fast
• Making it look good • ...oh, and don’t charge
my credit card twice
• Code refactoring
15. Nothing against them, but...
Foo Player not available for
your device
We restrict use of
technologies required by
products like Foo Player...
16. Quirkiness
Firefox Webkit (Safari) Opera IE
Typical portable 2876 ms 1276 ms 2053 ms 4078 ms
setInnerText()
textContent=... - 908 ms 1386 ms -
innerText=... 2477 ms 918 ms 1520 ms 2469 ms
DOM manipulation 7148 ms 1997 ms 4836 ms 14800 ms
17. Quirkiness
Firefox Webkit (Safari) Opera IE
Typical portable 2876 ms 1276 ms 2053 ms 4078 ms
setInnerText()
textContent=... - 908 ms 1386 ms -
innerText=... 2477 ms 918 ms 1520 ms 2469 ms
DOM manipulation 7148 ms 1997 ms 4836 ms 14800 ms
Improvement 14% 29% 32% 39%
18. Quirkiness
Firefox Webkit (Safari) Opera IE
Typical portable 2876 ms 1276 ms 2053 ms 4078 ms
setInnerText()
textContent=... - 908 ms 1386 ms -
innerText=... 2477 ms 918 ms 1520 ms 2469 ms
DOM manipulation 7148 ms 1997 ms 4836 ms 14800 ms
Improvement 14% 29% 32% 39%
http://quirksmode.org/blog/
19. Can you find the bug?
function getMax(values) {
var maximum = values[0];
for (var i = 0; i < values.length; ++i) {
if (values[i] > maximum) {
maxinum = values[i];
}
}
return maximum;
}
20. Can you find the bug?
function getMax(values) {
var maximum = values[0];
for (var i = 0; i < values.length; ++i) {
if (values[i] > maximum) {
maxinum = values[i];
}
}
return maximum;
}
Hint: Javascript is a dynamic language
29. From Eclipse to your browser
Eclipse
Browser Plugins
package com.google.gwt.samples.eclipsecon.client;
TCP
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
@SuppressWarnings("unused")
Code
public class EclipseCon implements EntryPoint {
Server
public void onModuleLoad() {
Window.alert("foo");
}
HTTP
}
Jetty
Server
20
30. From Eclipse to deployment
Your code... Generators Translators Linkers
package com.google.gwt.samples.eclipsecon.client;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
@SuppressWarnings("unused")
public class EclipseCon implements EntryPoint {
public void onModuleLoad() {
Window.alert("foo");
}
}
21
31. From Eclipse to deployment
Your code... Generators Translators Linkers
package com.google.gwt.samples.eclipsecon.client;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
@SuppressWarnings("unused")
public class EclipseCon implements EntryPoint {
public void onModuleLoad() {
Window.alert("foo");
}
}
22
32. Generators Provide the power behind your
GWT app
Automate away boilerplate code
Foundation for permutations
23
33. Use Case: GWT RPCs
Typical Ajax call
Serialization Serialization
Code Code
Client XHR Server
24
34. Use Case: GWT RPCs
GWT-enabled Ajax
Serialization Serialization
GWT Proxy
GWT Proxy
Code Code
Client XHR Server
25
35. Use Case: GWT RPCs
Goals:
• Serialization code begone
• RPCs like theyʼre meant to be -
interface methods
• Make it fast to boot
26
36. Use Case: GWT RPCs
You write code that looks like this:
@RemoteServiceRelativePath("suggest")
public interface SuggestService extends RemoteService {
String getSuggestions(String str) throws IllegalArgumentException;
}
27
39. From Eclipse to your browser
Your code... Generators Translators Linkers
package com.google.gwt.samples.eclipsecon.client;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
@SuppressWarnings("unused")
public class EclipseCon implements EntryPoint {
public void onModuleLoad() {
Window.alert("foo");
}
}
30
41. From Eclipse to your browser
Your code... Generators Translators Linkers
package com.google.gwt.samples.eclipsecon.client;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
@SuppressWarnings("unused")
public class EclipseCon implements EntryPoint {
public void onModuleLoad() {
Window.alert("foo");
}
}
32
43. GWT Tips and Tricks
-gen will output a copy of the
generated classes
34
44. GWT Tips and Tricks
Reduce optimizations, reduce compile time
-draftCompile
• Skip all optimizations
• Development only
45. GWT Tips and Tricks
Reduce optimizations, reduce compile time
-draftCompile
• Skip all optimizations
• Development only
Why worry about compiling at all?
46. A more efficient SDLC
Refresh Does it work? Yes Compile
No
Develop Deploy
51. Resource Bundling
One at a time
Image image = new Image("images/image1.gif");
image.setHeight("50px");
image.setWidth("50px");
imagesPanel.add(image);
53. Resource Bundling
All at once
public interface Resources extends ClientBundle {
public static final Resources INSTANCE = GWT.create(Resources.class);
@Source("Contacts.css")
public ContactsCss contactsCss();
@Source("images0.gif")
public ImageResource image0();
@Source("images1.gif")
public ImageResource image1();
...
}
58. Real world results - Google Wave
1500
1400 KB
Size of Initial JavaScript Download (KB)
1125
750
7x Decrease In
Initial Download Size
375
200 KB
0
26-Nov 29-Apr 18-Jun 28-Jul 12-Sep 27-Oct 24-Dec 16-Mar
59. Creating GWT apps - “Direct” approach
Write a bunch of widgets with self-contained
logic
Problems:
• Hard to test - need GWTTestCase
• Mocks not encouraged - harder to write smaller tests
• Platform specific UI code - limits code reuse
• Too many dependencies - difficult to optimize
60.
61. Creating GWT apps - MVP approach
Cast:
• Model - DTOs, and business logic
• View - The display
• Presenter - Application logic
Goals:
• Be practical
• Avoid rigid patterns
• Put the complex logic in your Presenters
• Put the widget code in your Views
• Make the Views as dumb as possible
- So what is GWT....
- It&#x2019;s a toolkit and not a framework. With GWT you can pick an choose to use certain tools that we offer without buying into all of them.
- Maybe you want to use GWT&#x2019;s RPC mechanism alongside your existing Javascript, or you may want to write your frontend in GWT and leave your server-side code as it exists today.
- It&#x2019;s all completely doable. In fact the only thing you have to buy into, is writing Web Apps in Java.
- Which leads me to point #2, Code in Java...run as Javascript. At the heart of GWT is a Java to Javascript compiler that (besides producing Javascript) optimizes and obfuscates this Javascript
- Separate Javascript is produced for each browser, we refer to these as permutations, and it&#x2019;s what allows facilitates correct behavior within each browser.
- You maintain a single Java codebase, and let GWT handle the browser quirks.
- XHRs aren&#x2019;t rocket science, by the code to handle them can get messy. RPCs in a GWT app look like nothing more than a method call on a class, and on top of that GWT&#x2019;s RPC generator helps optimize the serialization of objects over the wire.
- Finally, we eat generous amounts of our own dogfood. As mentioned before, this presentation is largely about what other teams learned over the past year. Wave and Ad Words are two products that, not only challenged browser capabilities, but GWT capabilities as well.
- So what is GWT....
- It&#x2019;s a toolkit and not a framework. With GWT you can pick an choose to use certain tools that we offer without buying into all of them.
- Maybe you want to use GWT&#x2019;s RPC mechanism alongside your existing Javascript, or you may want to write your frontend in GWT and leave your server-side code as it exists today.
- It&#x2019;s all completely doable. In fact the only thing you have to buy into, is writing Web Apps in Java.
- Which leads me to point #2, Code in Java...run as Javascript. At the heart of GWT is a Java to Javascript compiler that (besides producing Javascript) optimizes and obfuscates this Javascript
- Separate Javascript is produced for each browser, we refer to these as permutations, and it&#x2019;s what allows facilitates correct behavior within each browser.
- You maintain a single Java codebase, and let GWT handle the browser quirks.
- XHRs aren&#x2019;t rocket science, by the code to handle them can get messy. RPCs in a GWT app look like nothing more than a method call on a class, and on top of that GWT&#x2019;s RPC generator helps optimize the serialization of objects over the wire.
- Finally, we eat generous amounts of our own dogfood. As mentioned before, this presentation is largely about what other teams learned over the past year. Wave and Ad Words are two products that, not only challenged browser capabilities, but GWT capabilities as well.
Alright, a quick demo to give you a baseline idea of what we&#x2019;re talking about.
Here I have a simple HelloWorld demo that has a textbox, a few labels, and a button.
Upon button click, we&#x2019;ll make an RPC call that returns the string we sent it plus some other stats regarding the app server it&#x2019;s running on.
All pretty straight forward stuff...right?
Let&#x2019;s set some breakpoints....
Change the defaults text values...
Swap out the &#x201C;Send&#x201D; button with a demo button...what do I need to define to implement ClickHanlder?...ahh thanks Plugin
Btw...note that we&#x2019;re running in our browser of choice, a big improvement in 2.0
Alright, a quick demo to give you a baseline idea of what we&#x2019;re talking about.
Here I have a simple HelloWorld demo that has a textbox, a few labels, and a button.
Upon button click, we&#x2019;ll make an RPC call that returns the string we sent it plus some other stats regarding the app server it&#x2019;s running on.
All pretty straight forward stuff...right?
Let&#x2019;s set some breakpoints....
Change the defaults text values...
Swap out the &#x201C;Send&#x201D; button with a demo button...what do I need to define to implement ClickHanlder?...ahh thanks Plugin
Btw...note that we&#x2019;re running in our browser of choice, a big improvement in 2.0
Alright, a quick demo to give you a baseline idea of what we&#x2019;re talking about.
Here I have a simple HelloWorld demo that has a textbox, a few labels, and a button.
Upon button click, we&#x2019;ll make an RPC call that returns the string we sent it plus some other stats regarding the app server it&#x2019;s running on.
All pretty straight forward stuff...right?
Let&#x2019;s set some breakpoints....
Change the defaults text values...
Swap out the &#x201C;Send&#x201D; button with a demo button...what do I need to define to implement ClickHanlder?...ahh thanks Plugin
Btw...note that we&#x2019;re running in our browser of choice, a big improvement in 2.0
Alright, a quick demo to give you a baseline idea of what we&#x2019;re talking about.
Here I have a simple HelloWorld demo that has a textbox, a few labels, and a button.
Upon button click, we&#x2019;ll make an RPC call that returns the string we sent it plus some other stats regarding the app server it&#x2019;s running on.
All pretty straight forward stuff...right?
Let&#x2019;s set some breakpoints....
Change the defaults text values...
Swap out the &#x201C;Send&#x201D; button with a demo button...what do I need to define to implement ClickHanlder?...ahh thanks Plugin
Btw...note that we&#x2019;re running in our browser of choice, a big improvement in 2.0
Alright, a quick demo to give you a baseline idea of what we&#x2019;re talking about.
Here I have a simple HelloWorld demo that has a textbox, a few labels, and a button.
Upon button click, we&#x2019;ll make an RPC call that returns the string we sent it plus some other stats regarding the app server it&#x2019;s running on.
All pretty straight forward stuff...right?
Let&#x2019;s set some breakpoints....
Change the defaults text values...
Swap out the &#x201C;Send&#x201D; button with a demo button...what do I need to define to implement ClickHanlder?...ahh thanks Plugin
Btw...note that we&#x2019;re running in our browser of choice, a big improvement in 2.0
Alright, a quick demo to give you a baseline idea of what we&#x2019;re talking about.
Here I have a simple HelloWorld demo that has a textbox, a few labels, and a button.
Upon button click, we&#x2019;ll make an RPC call that returns the string we sent it plus some other stats regarding the app server it&#x2019;s running on.
All pretty straight forward stuff...right?
Let&#x2019;s set some breakpoints....
Change the defaults text values...
Swap out the &#x201C;Send&#x201D; button with a demo button...what do I need to define to implement ClickHanlder?...ahh thanks Plugin
Btw...note that we&#x2019;re running in our browser of choice, a big improvement in 2.0
Alright, a quick demo to give you a baseline idea of what we&#x2019;re talking about.
Here I have a simple HelloWorld demo that has a textbox, a few labels, and a button.
Upon button click, we&#x2019;ll make an RPC call that returns the string we sent it plus some other stats regarding the app server it&#x2019;s running on.
All pretty straight forward stuff...right?
Let&#x2019;s set some breakpoints....
Change the defaults text values...
Swap out the &#x201C;Send&#x201D; button with a demo button...what do I need to define to implement ClickHanlder?...ahh thanks Plugin
Btw...note that we&#x2019;re running in our browser of choice, a big improvement in 2.0
Alright, a quick demo to give you a baseline idea of what we&#x2019;re talking about.
Here I have a simple HelloWorld demo that has a textbox, a few labels, and a button.
Upon button click, we&#x2019;ll make an RPC call that returns the string we sent it plus some other stats regarding the app server it&#x2019;s running on.
All pretty straight forward stuff...right?
Let&#x2019;s set some breakpoints....
Change the defaults text values...
Swap out the &#x201C;Send&#x201D; button with a demo button...what do I need to define to implement ClickHanlder?...ahh thanks Plugin
Btw...note that we&#x2019;re running in our browser of choice, a big improvement in 2.0
Alright, a quick demo to give you a baseline idea of what we&#x2019;re talking about.
Here I have a simple HelloWorld demo that has a textbox, a few labels, and a button.
Upon button click, we&#x2019;ll make an RPC call that returns the string we sent it plus some other stats regarding the app server it&#x2019;s running on.
All pretty straight forward stuff...right?
Let&#x2019;s set some breakpoints....
Change the defaults text values...
Swap out the &#x201C;Send&#x201D; button with a demo button...what do I need to define to implement ClickHanlder?...ahh thanks Plugin
Btw...note that we&#x2019;re running in our browser of choice, a big improvement in 2.0
Alright, a quick demo to give you a baseline idea of what we&#x2019;re talking about.
Here I have a simple HelloWorld demo that has a textbox, a few labels, and a button.
Upon button click, we&#x2019;ll make an RPC call that returns the string we sent it plus some other stats regarding the app server it&#x2019;s running on.
All pretty straight forward stuff...right?
Let&#x2019;s set some breakpoints....
Change the defaults text values...
Swap out the &#x201C;Send&#x201D; button with a demo button...what do I need to define to implement ClickHanlder?...ahh thanks Plugin
Btw...note that we&#x2019;re running in our browser of choice, a big improvement in 2.0
In the context of &#x201C;Best Practices&#x201D; I&#x2019;m going to focus on these features today....
In the context of &#x201C;Best Practices&#x201D; I&#x2019;m going to focus on these features today....
In the context of &#x201C;Best Practices&#x201D; I&#x2019;m going to focus on these features today....
In the context of &#x201C;Best Practices&#x201D; I&#x2019;m going to focus on these features today....
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
Now, if you just jump into writing a GWT application, as we&#x2019;ve done a fair number of times, what's the most obvious approach?
- Subclass composite or complex panel or whatever, run the app, debug with developer mode, etc.
- First of all, as your application grows, it&#x2019;s going to become harder to test because it relies on GWTTestCase
* What&#x2019;s GWTTestCase you say? Good question. GWTTestCase wraps a JUnit test case and runs your tests within a headless browser. Which is really cool because you can easily test code that would require some testing harness, selenium integration, etc... That said, it does take longer (much longer) to execute these tests because...well...you&#x2019;re starting large parts of your application within a browser.
* And any test that requires a DOM to perform layout, amongst other tasks, is going to require a GWTTestCase. Put another way, GWT Widgets require you to test in the browser.
- Secondly, mocks are not encouraged. Tools like EasyMock don&#x2019;t play well within a GWTTestCase.
- You increase the chance that you have platform independent and dependent code intertwined, which limits code reuse. Use this for context...we want to create an app that will run in both desktop and mobile browsers. The one glaring differences in these platforms is their UI, so it makes sense to limit the amount of code we place here.
- Finally, you end up with dependency spaghetti. Your UI code knows about your DTOs, can make some RPCs, has all of the application logic built in to handle UI events, etc...
Now, if you just jump into writing a GWT application, as we&#x2019;ve done a fair number of times, what's the most obvious approach?
- Subclass composite or complex panel or whatever, run the app, debug with developer mode, etc.
- First of all, as your application grows, it&#x2019;s going to become harder to test because it relies on GWTTestCase
* What&#x2019;s GWTTestCase you say? Good question. GWTTestCase wraps a JUnit test case and runs your tests within a headless browser. Which is really cool because you can easily test code that would require some testing harness, selenium integration, etc... That said, it does take longer (much longer) to execute these tests because...well...you&#x2019;re starting large parts of your application within a browser.
* And any test that requires a DOM to perform layout, amongst other tasks, is going to require a GWTTestCase. Put another way, GWT Widgets require you to test in the browser.
- Secondly, mocks are not encouraged. Tools like EasyMock don&#x2019;t play well within a GWTTestCase.
- You increase the chance that you have platform independent and dependent code intertwined, which limits code reuse. Use this for context...we want to create an app that will run in both desktop and mobile browsers. The one glaring differences in these platforms is their UI, so it makes sense to limit the amount of code we place here.
- Finally, you end up with dependency spaghetti. Your UI code knows about your DTOs, can make some RPCs, has all of the application logic built in to handle UI events, etc...
Now, if you just jump into writing a GWT application, as we&#x2019;ve done a fair number of times, what's the most obvious approach?
- Subclass composite or complex panel or whatever, run the app, debug with developer mode, etc.
- First of all, as your application grows, it&#x2019;s going to become harder to test because it relies on GWTTestCase
* What&#x2019;s GWTTestCase you say? Good question. GWTTestCase wraps a JUnit test case and runs your tests within a headless browser. Which is really cool because you can easily test code that would require some testing harness, selenium integration, etc... That said, it does take longer (much longer) to execute these tests because...well...you&#x2019;re starting large parts of your application within a browser.
* And any test that requires a DOM to perform layout, amongst other tasks, is going to require a GWTTestCase. Put another way, GWT Widgets require you to test in the browser.
- Secondly, mocks are not encouraged. Tools like EasyMock don&#x2019;t play well within a GWTTestCase.
- You increase the chance that you have platform independent and dependent code intertwined, which limits code reuse. Use this for context...we want to create an app that will run in both desktop and mobile browsers. The one glaring differences in these platforms is their UI, so it makes sense to limit the amount of code we place here.
- Finally, you end up with dependency spaghetti. Your UI code knows about your DTOs, can make some RPCs, has all of the application logic built in to handle UI events, etc...
Now, if you just jump into writing a GWT application, as we&#x2019;ve done a fair number of times, what's the most obvious approach?
- Subclass composite or complex panel or whatever, run the app, debug with developer mode, etc.
- First of all, as your application grows, it&#x2019;s going to become harder to test because it relies on GWTTestCase
* What&#x2019;s GWTTestCase you say? Good question. GWTTestCase wraps a JUnit test case and runs your tests within a headless browser. Which is really cool because you can easily test code that would require some testing harness, selenium integration, etc... That said, it does take longer (much longer) to execute these tests because...well...you&#x2019;re starting large parts of your application within a browser.
* And any test that requires a DOM to perform layout, amongst other tasks, is going to require a GWTTestCase. Put another way, GWT Widgets require you to test in the browser.
- Secondly, mocks are not encouraged. Tools like EasyMock don&#x2019;t play well within a GWTTestCase.
- You increase the chance that you have platform independent and dependent code intertwined, which limits code reuse. Use this for context...we want to create an app that will run in both desktop and mobile browsers. The one glaring differences in these platforms is their UI, so it makes sense to limit the amount of code we place here.
- Finally, you end up with dependency spaghetti. Your UI code knows about your DTOs, can make some RPCs, has all of the application logic built in to handle UI events, etc...
Now, if you just jump into writing a GWT application, as we&#x2019;ve done a fair number of times, what's the most obvious approach?
- Subclass composite or complex panel or whatever, run the app, debug with developer mode, etc.
- First of all, as your application grows, it&#x2019;s going to become harder to test because it relies on GWTTestCase
* What&#x2019;s GWTTestCase you say? Good question. GWTTestCase wraps a JUnit test case and runs your tests within a headless browser. Which is really cool because you can easily test code that would require some testing harness, selenium integration, etc... That said, it does take longer (much longer) to execute these tests because...well...you&#x2019;re starting large parts of your application within a browser.
* And any test that requires a DOM to perform layout, amongst other tasks, is going to require a GWTTestCase. Put another way, GWT Widgets require you to test in the browser.
- Secondly, mocks are not encouraged. Tools like EasyMock don&#x2019;t play well within a GWTTestCase.
- You increase the chance that you have platform independent and dependent code intertwined, which limits code reuse. Use this for context...we want to create an app that will run in both desktop and mobile browsers. The one glaring differences in these platforms is their UI, so it makes sense to limit the amount of code we place here.
- Finally, you end up with dependency spaghetti. Your UI code knows about your DTOs, can make some RPCs, has all of the application logic built in to handle UI events, etc...
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
- Now that we&#x2019;re all on the same page, let&#x2019;s jump into the discussion of GWT Best Practices
- Not that this is a comprehensive list, but these are the items that have been top of mind for a few months now
- We&#x2019;ll tackle the largest first, how to reap the benefits of a MVP-based app when using GWT
- In the process, we&#x2019;ll explain how to integrate Declarative UIs (mainly how to hook up UI events)
- With our architecture in place, we&#x2019;ll follow-up with several optimization techniques
* Bundling Resources
* Code Splitting
* And Prefetching RPCs
Now that we&#x2019;ve tackled architecture and testing, it&#x2019;s time to look at how we can optimize our application
While there are a plethora of techniques, here are 3 that we&#x2019;ve found useful when building large scale applications
Resource bundling...
So let&#x2019;s assume we want to allow users to associate icons with their contacts...
Yes, typically this would be facilitated by users selecting icons or images from disk...but bear with me for the sake of this example, and assume we&#x2019;re pulling them down from a server
We could choose to pull these images one at a time...
In which case we&#x2019;d end up with a request pattern that looks like this
Fetch the initial html page, followed-up by a request for our nocache.js file
And then at some point in time we&#x2019;ll request all of the images to select from
Not bad, but there&#x2019;s a large amount of HTTP overhead that we can remove from this flow
Remember, your users aren&#x2019;t always right next to your data center...even worse, more and more of them will be on mobile networks
3G networks are fast, but drop off points can be frequent and the cost of building that connection back up can be more than noticeable
Instead of pulling the images one at a time, we can define a Resources interface that overlays methods on top of our images
The ClientBundle generator will then
- Pull the necessary files together
- Generate code that allows us to access each accordingly
Think of it as spriting for all file types...we don&#x2019;t discriminate
You can see that our images are now bundled along with our initial JS call
And the subsequent call to display the images has almost zero overhead...basically all we&#x2019;re paying for is the images that make up the decorator panel
But we can do better
While we&#x2019;ve managed to reduce HTTP overhead by bundling all of our resources, they&#x2019;re in turn downloaded during application load
When in reality we only need them when the user navigates to the select Contact icon page
Now, if you just jump into writing a GWT application, as we&#x2019;ve done a fair number of times, what's the most obvious approach?
- Subclass composite or complex panel or whatever, run the app, debug with developer mode, etc.
- First of all, as your application grows, it&#x2019;s going to become harder to test because it relies on GWTTestCase
* What&#x2019;s GWTTestCase you say? Good question. GWTTestCase wraps a JUnit test case and runs your tests within a headless browser. Which is really cool because you can easily test code that would require some testing harness, selenium integration, etc... That said, it does take longer (much longer) to execute these tests because...well...you&#x2019;re starting large parts of your application within a browser.
* And any test that requires a DOM to perform layout, amongst other tasks, is going to require a GWTTestCase. Put another way, GWT Widgets require you to test in the browser.
- Secondly, mocks are not encouraged. Tools like EasyMock don&#x2019;t play well within a GWTTestCase.
- You increase the chance that you have platform independent and dependent code intertwined, which limits code reuse. Use this for context...we want to create an app that will run in both desktop and mobile browsers. The one glaring differences in these platforms is their UI, so it makes sense to limit the amount of code we place here.
- Finally, you end up with dependency spaghetti. Your UI code knows about your DTOs, can make some RPCs, has all of the application logic built in to handle UI events, etc...
Another way of approaching the problem is with the MVP pattern. A couple of points tough:
- Be practical, don&#x2019;t assume that every aspect of the MVP pattern is applicable to your application
- Put the complex logic in your Presenters, and make them testable using vanilla JRE tests
- Try to contain your widget code, minimize logic that requires GWTTestCase.
- Don&#x2019;t create views in your presenter&#x2019;s ctors, doing so makes it impossible to mock them out for testing later
- Make the Views as dumb as possible, widget/display code is ideally "correct by construction"
Another way of approaching the problem is with the MVP pattern. A couple of points tough:
- Be practical, don&#x2019;t assume that every aspect of the MVP pattern is applicable to your application
- Put the complex logic in your Presenters, and make them testable using vanilla JRE tests
- Try to contain your widget code, minimize logic that requires GWTTestCase.
- Don&#x2019;t create views in your presenter&#x2019;s ctors, doing so makes it impossible to mock them out for testing later
- Make the Views as dumb as possible, widget/display code is ideally "correct by construction"