I am using the selection model and the [...]]]> Here is a simple column header that selects/ de-selects all rows in a table. When all rows are checked, the header becomes checked automatically. Clicking o the checkbox in the header causes either to select or de-select all rows.

I am using the selection model and the data list provider to do the selection magic.

May not work for everyone….

And here is my custom header:

public final class CheckboxHeader extends Header {
 
	private final MultiSelectionModel selectionModel;
	private final ListDataProvider provider;
 
	public CheckboxHeader(MultiSelectionModel selectionModel,
			ListDataProvider provider) {
		super(new CheckboxCell());
		this.selectionModel = selectionModel;
		this.provider = provider;
	}
 
	@Override
	public Boolean getValue() {
		boolean allItemsSelected = selectionModel.getSelectedSet().size() == provider
				.getList().size();
		return allItemsSelected;
	}
 
	@Override
	public void onBrowserEvent(Context context, Element elem, NativeEvent event) {
		InputElement input = elem.getFirstChild().cast();
		Boolean isChecked = input.isChecked();
		for (TYPE element : provider.getList()) {
			selectionModel.setSelected(element, isChecked);
		}
	}
 
}

Entstanden sind zwei Instrumente, die für uns GWT-Interessierte relevant sein könnten: zum einen geht es um eine Studie, die im kleinen Kreis den Einsatz von GWT in deutschen Unternehmen dokumentiert, zum anderen geht es tatsächlich um eine Liste mit [...]]]> Ich möchte kurz auf zwei Dinge aufmerksam machen, die mich in letzter Zeit beschäftigt haben…

Entstanden sind zwei Instrumente, die für uns GWT-Interessierte relevant sein könnten: zum einen geht es um eine Studie, die im kleinen Kreis den Einsatz von GWT in deutschen Unternehmen dokumentiert, zum anderen geht es tatsächlich um eine Liste mit Unternehmen, die GWT einsetzen.

OIO Kompass : Java Web-Frameworks

Im letzten Jahr habe ich in Zusammenarbeit mit der Firma Orientaion in Objects, Mannheim, im kleinen Kreis eine Umfrage zu den Hintergründen der Auswahl von Java Web-Frameworks im deutschsprachigen Raum durchgeführt.

Die Studie, die wir kürzlich veröffentlicht haben, beruhte auf 50 Entscheidungen. Von diesen Entscheidungen waren ca. 250 Entwickler und 200 Projekte betroffen. Genug, um eine erste Studie zu veröffentlichen. Die Studie kann auch als PDF geladen werden.

Unter dem reisserischem Titel Java-Frameworks: Zweikampf zwischen JSF und GWT hatte unsere kleine Studie einen kleinen Auftritt in den Medien.

Und somit ist auch die zweite Runde eingeleitet: mit einem überarbeiteten Fragebogen wollen wir die Studie nochmal im großen Kreis durchführen.

Hier geht es direkt zur aktuellen Umfrage.

Für die Beantwortung der Fragen veranschlagen wir rund 10 bis 15 Minuten:

GWT Referenzliste

In den letzten Jahren wurde ich unzählige Male danach gefragt, welche Unternehmen GWT einsetzen würden. In diesem Kontext ist eine kleine GWT Anwendung entstanden, in der sich Unternehmen anmelden können, die GWT im Einsatz haben.

Inzwischen sind 80+ Unternehmen eingetragen, darunter 20++ aus Deutschland und 20++ aus den USA.

Die Liste ist öffentlich zugänglich, die Kontaktdaten werden nicht veröffentlicht (dienen nur für Rückfragen und Verifizierung). Optional können ein paar Angaben zum Kontext gemacht werden, daraus entstehen die netten Statistiken, die ebenfalls öffentlich zugänglich sind.

Mit ein bisschen Hilfe können wir sicherlich die Anzahl der deutschen Unternehmen in der Liste deutlich erhöhen. Für die Registrierung werden keine 5 Minuten veranschlagt…

Als Java-Entwickler ist man nicht selten Webentwickler. Über einen ungewöhnlich langen Zeitraum haben sich die Technologien um einen herum kaum geändert: Das W3C hat sich in Bezug auf HTML lange seitwärts, insgesamt im Kreis, aber praktisch kaum bewegt, der Browserkrieg schien gewonnen und mit den Java-Webframeworks waren wir im Großen und [...]]]> Zeiten des Wandels

Als Java-Entwickler ist man nicht selten Webentwickler. Über einen ungewöhnlich langen Zeitraum haben sich die Technologien um einen herum kaum geändert: Das W3C hat sich in Bezug auf HTML lange seitwärts, insgesamt im Kreis, aber praktisch kaum bewegt, der Browserkrieg schien gewonnen und mit den Java-Webframeworks waren wir im Großen und Ganzen recht zufrieden.

The Web 2.0 Toolkit

Das Google Web Toolkit ist eine Sammlung von Werkzeugen und Bibliotheken für die Entwicklung von JavaScript-Anwendungen. Das Toolkit wird sowohl intern von Google als auch weltweit in vielen Projekten eingesetzt. Das Besondere an GWT ist die Vorgehensweise: Ein Compiler liest Java-Quellen ein und generiert JavaScript. Somit können Java-Entwickler auf bestehendes Wissen, Erfahrungen und Werkzeuge aufsetzen. Allerdings hat GWT nicht den Versuch unternommen, das gesamte JDK und Swing im Browser zu unterstützen. Die JDK-Unterstützung ist fragmentarisch (nicht alle Klassen können verwendet werden), und GWT liefert ein eigenes, an HTML orientiertes
UI-Komponentenmodell.

Der komplette Artikel von Benjamin Bart (Orientation in Objects GmbH) und Papick G. Taboada (pgt technology scouting GmbH)  kann im PDF nachgelesen werden und stammt aus der Ausgabe 2.12 des Eclipse Magazins.

In GWT we did something like that to cancel the backspace back navigation:

First, there is Google:

„AdWords, AdSense, Flights, Hotel Finder, Offers, Wallet, The New Blogger, Chrome Webstore, Product Search, Public Data, New Google Groups, Orkut, Google Takeout, Google Pagespeed, Google WebFonts, Google Tables, Google Health (discontinued), Google Wave (discontinued), PlayN (basis of Angry Birds)“

And now, online, there is a public reference list of companies using GWT:

http://gwtreferencelist.appspot.com/

But this time, the team posted several comments on whether GWT is dead or not (mainly because of the fuss around Dart), and Ray Cromwell posted a comment providing some insight on what is [...]]]> Normally the GWT team does not comment on future milestones, releases and does not provide an official roadmap (Issue 7013).

But this time, the team posted several comments on whether GWT is dead or not (mainly because of the fuss around Dart), and Ray Cromwell posted a comment providing some insight on what is coming on GWT 2.5:

The next release or two of GWT may include more core improvements than the last few point releases of GWT so far, consider:

1) Compiler optimizations that reduce code by size by 30% uncompressed, and 15% gzipped
2) SourceMap support and Source-Level Java debugging in Chrome (and hopefully Firefox)
3) A „super draft mode“ that can recompile many apps in under 10 seconds and most under 5
4) New „to the metal“ „modern browser“ HTML bindings
5) Testing framework that makes GUI testing delightful
6) Incremental compile support to speed up production compiles

So code will be getting smaller, faster, easier to debug (in some situations) and test, and compiles will go quicker. This reflects somewhat the shift in GWT team composition, but as people ramp up on other parts of the SDK (e.g. MVP stuff), I’m sure there will be improved responsiveness to fixing bugs in that area as well.

Add this to the list of issues already fixed and scheduled for 2.5, and we will have a really interesting release.

Oder direkt hier: http://bit.ly/gwt-jsf-wahlomat

It was a very interesting evening, great feedback and nice chatting afterwards. Recapping, we had a talk on RAP, the Canoo RIA thing, Silverlight and Qooxdoo. I jumped in with my talk [...]]]> It is not easy to “sneak preview” any technology in 20 minutes… I was the last in a row of five “RIA” technologies talks.

It was a very interesting evening, great feedback and nice chatting afterwards. Recapping, we had a talk on RAP, the Canoo RIA thing, Silverlight and Qooxdoo. I jumped in with my talk on GWT, my third slide says: “GWT is better”:

Here are the slides I used in the VKSI sneak preview “RIA Entwicklungsplattformen im Vergleich“.

Many companies are still stuck in – IMHO – the most successfull vendor-version lock-in web history. Ever heard this?

I cannot upgrade IE in our company because of [...]]]> When you start developing complex enterprise applications using GWT, you can run into the problem that IE does not perform quite well with too much JavaScript.

Many companies are still stuck in – IMHO – the most successfull vendor-version lock-in web history. Ever heard this?

I cannot upgrade IE in our company because of  (…)*

(*) You can fill in you favorite corporate intranet application that won’t work elsewhere, only in IE6.

And even if you can upgrade IE to the latest version (actually IE8), it won’t get much better. Chrome, Opera, Firefox and Safari – pic anyone and you will see that the RIA in question can be fast.

And here is where Google comes to the rescue. In a recent blog posting, the Chromium declared that “chrome is ready for business“:

Both Chrome and Chromium are now manageable through Group Policy objects on Windows, plist/MCX configuration on Mac, and special JSON configuration files on Linux. We polished up the NTLM and Kerberos protocol support, and created a list of supported policies and administrative templates to help administrators deploy.

This is good news for companies willing to switch from IE to chrome, but for those sticking to IE we still have the nochrome-vendor-version lock-in. And this is the greatest problem: how do you switch to a modern browser, if you must run several applications in IE? The answer is simple: you switch the rendering engine inside IE, but not for all applications, just for those explicitly asking for it:

For users needing access to older web applications not yet qualified for Chrome, we also developed Chrome Frame, an Internet Explorer (TM) plug-in that provides Chrome-quality rendering for the broader Web, while defaulting to host rendering for any web applications that still require IE.

This way, IE will work as always, but if some page adds a simple html or http header, google chrome will do the rendering of the page, inside IE. Users don’t have to switch from one browser to another, and the IT department can rollout one web application upgrade after another, without compromising legacy apps.

You could even use a proxy with content adaptation to add the required http header to all pages from the internet.

I mean, really, even Microsoft says you should upgrade:

Microsoft’s urging to upgrade to IE8 appears to be partially in response to the German and French governments’ recommendation that people stop using Internet Explorer altogether due to its security vulnerabilities.

Microsoft’s announcement said: “It is important to note that all software has vulnerabilities and switching browsers in an attempt to protect against this one, highly publicized, but currently limited attack can inadvertently create some false sense of security. Moreover, IE8 has other built-in security protections, such as the SmartScreen filter, that other browsers do not have that protect against real consumer threats, such as socially engineered malware and phishing attacks.”

My first though is, what exactly is meant with “standard”? A short look at Wikipedia shows:

Open Standard: An open standard is a standard that is publicly available and has [...]]]> This is a sort of “standard” question when it comes down to the topic web frameworks, Java and finally the Google Web Toolkit (GWT).

My first though is, what exactly is meant with “standard”?

A short look at Wikipedia shows:

Open Standard: An open standard is a standard that is publicly available and has various rights to use associated with it, and may also have various properties of how it was designed (e.g. open process). There is no single definition and interpretations do vary with usage.

De facto standard: A de facto standard is a custom, convention, product, or system that has achieved a dominant position by public acceptance or market forces (such as early entrance to the market). De facto is a Latin phrase meaning “concerning the fact” or “in practice”.

Internet standard: In computer network engineering, an Internet Standard (STD) is a normative specification of a technology or methodology applicable to the Internet. Internet Standards are created and published by the Internet Engineering Task Force (IETF).

No, no,  no! Not that kind of standard, right? Ah, ok, the Java EE standard!

Again, looking at Wikipedia you will find the following under “nomenclature, standards and specification“:

Java EE is defined by its specification. As with other Java Community Process specifications, providers must meet certain conformance requirements in order to declare their products as Java EE compliant.

Java EE includes several API specifications, such as JDBC, RMI, e-mail, JMS, web services, XML, etc., and defines how to coordinate them. Java EE also features some specifications unique to Java EE for components. These include Enterprise JavaBeans, Connectors, servlets, portlets (following the Java Portlet specification), JavaServer Pages and several web service technologies. This allows developers to create enterprise applications that are portable and scalable, and that integrate with legacy technologies.

Which leaves us just a few options: the Servlet/ JSP and the JavaServer Faces specifications. While the Servlet and JSP specifications focus on how to handle HTTP request/ responses, the JSF specification defines a GUI component model for web applications.

The problem here is: there is no room anymore for another “compliant” web framework – JSF made it into the Java EE specification – end of line. But, despite of a wide industry support, JSF is not the only web framework being used today by Java developers. And to make things a little more trickier, typical Web 2.0 web applications do not render the UI on the server side but in the browser.

Fancy “Web 2.0″ applications are not written in Java. Rich user interfaces are being rendered completely in the browser, avoiding the server roundtrip and minimizing latency. How? By simply using DHTML (technologies defined by the W3C).

So is this the end of Java? No! You will find people using Java backends for “Web 2.0″ applications. But even as a backend technology we won’t be abiding by the rules of standard compliance by using RMI or SOAP to communicate: it is common to send lightweight JSON over HTTP. All you need for that is a Servlet and a little bit of JSON <-> Java objects mapping. People developing RIAs and using JSON back and forward to the server are measuring latency in milliseconds.

So, if you will be building a Web 2.0 application, don’t look for a specification at the Java EE side. It is the wrong side, as Java is actually the backend, not the frontend. That brings us back to the first standards I cited above: open standards, de facto standards and internet standards.

This is how things were before JSF, and this is how things became after Web 2.o.

So, back to the question, is GWT standard compliant or not? Well, besides of those blue boxes on the picture above I would say yes!

• The compiler is not standard, but I would not know what a standard compiler would be or mean to development anyway
• The GWT-RPC mechanism is highly GWT proprietary, don’t use it if you don’t like it. But it is my belief that there aren’t too many developers out there that can code something better than GWT-RPC by hand…

The GWT generated files make it quite easy to follow some of the tips for building a cache-aware site:

If a resource (especially a downloadable file) changes, change its name. That way, you can make it [...]]]> GWT applications are basically a bunch of static resources, and static resources are strong candidates for browser caching.

The GWT generated files make it quite easy to follow some of the tips for building a cache-aware site:

If a resource (especially a downloadable file) changes, change its name. That way, you can make it expire far in the future, and still guarantee that the correct version is served; the page that links to it is the only one that will need a short expiry time.

If we have a look at the generated files we will find

• strongly unique filenames
• cache and nocache hints in the filename

It would be possible to add servlet filters to the Java EE Web Container (I will call it tomcat from now on…) delivering those files, but I prefer to have it outside of tomcat. As long as I don’t find the “GWT optimization all-in-one-filter” I will keep using the Apache http server for optimization. Besides, it is not unusual to hide one ore more tomcat instances behind an Apache http server.

Well, I found it quite tricky to setup compression, http headers and the right proxy configuration, so here is my config as of today…

I am using mod_deflate, mod_expires and mod_headers, mod_proxy and mod_proxy_ajp. It is up to you to have those loaded in your Apache configuration. Load balancing with mod_proxy_balancer is out of scope for this article.

So here is my configuration:
[update]
I added a version number to the configuration.
[/update]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#
#  Version 2
#  Source: http://pgt.de/2011/01/27/apache-configuration-for-gwt-applications/
#
<IfModule mod_proxy.c>
   <IfModule mod_proxy_ajp.c>
 
      <IfModule mod_expires.c>
         ExpiresActive On
      </IfModule>          
 
      <IfModule mod_headers.c>
         <ProxyMatch (.*)nocache\.js$>
            Header Set Cache-Control "max-age=0, no-store"
         </ProxyMatch>
         <ProxyMatch (.*)\.cache\.(.*)>
            Header Set Cache-Control "max-age=31536000, public, must-revalidate"
         </ProxyMatch>
         <ProxyMatch (.*)\.cache\.js$>
            Header Set Cache-Control "max-age=31536000, private"
         </ProxyMatch>
      </IfModule>          
 
      <IfModule mod_deflate.c>
         SetOutputFilter DEFLATE
         AddOutputFilterByType DEFLATE text/plain
         AddOutputFilterByType DEFLATE text/html 
         AddOutputFilterByType DEFLATE text/xml  
         AddOutputFilterByType DEFLATE text/css  
         AddOutputFilterByType DEFLATE text/javascript
         AddOutputFilterByType DEFLATE application/xml
         AddOutputFilterByType DEFLATE application/xhtml+xml
         AddOutputFilterByType DEFLATE application/rss+xml  
         AddOutputFilterByType DEFLATE application/javascript
         AddOutputFilterByType DEFLATE application/x-javascript
         AddOutputFilterByType DEFLATE application/x-shockwave-flash
      </IfModule>          
 
      <Proxy *>
         <IfModule mod_expires.c>
            ExpiresByType application/json   "now"
            ExpiresByType text/css            "now"
            ExpiresByType text/html          "now"
         </IfModule>
         <ifModule mod_headers.c>
             Header unset ETag
             Header unset Last-Modified
         </ifModule>
         FileETag None
      </Proxy>
 
      <Location /gwt>
         ProxyPass         ajp://localhost:8009/gwt
         Order allow,deny
         Allow from all  
      </Location> 
 
   </IfModule>          
</IfModule>

As you can see I turned off caching of css and html files for my GWT app for a simple reason: my GWT apps follow the single page principle, so users won’t leave/ reload the page. And when they do, it is ok to deliver the actual version. You can fill in your own strategy here, depending on your own application lifecycle.

The compression is working fine, as you can see at the difference between the size and the transfered size:

As configured, the expiration headers for the cacheable filenames are set to the far future, here are the headers for a split point:

And, as required to get updated GWT apps pushed to the clients on a browser refresh, the http header for the not cacheable file:

Building any large scale application has its hurdles, and GWT apps are no exception. Multiple developers working simultaneously on the same code base, while maintaining legacy features and [...]]]> There is a two part article on the GWT docs homepage talking about large scale application development and GWT. Sorry, this is a crosspost from here…

Building any large scale application has its hurdles, and GWT apps are no exception. Multiple developers working simultaneously on the same code base, while maintaining legacy features and functionality, can quickly turn into messy code. To help sort things out we introduce design patterns to create compartmentalized areas of responsibility within our project.

Part I

http://code.google.com/intl/de/webtoolkit/articles/mvp-architecture.html

Model view presenter, AppController, binding presenters and views, EventBus, history, testing

Part II

http://code.google.com/intl/de/webtoolkit/articles/mvp-architecture-2.html

Complex UIs, optimized UIs, and code splitting.

Google usually publishes the sessions on youtube and uploads the slides to the respective session homepage. Ray Ryan is talking on two session, one of it is called “Architecting GWT applications for production at Google” – maybe it [...]]]> Here are the GWT sessions on the upcoming google i/o 2010 to keep an eye on.

Google usually publishes the sessions on youtube and uploads the slides to the respective session homepage. Ray Ryan is talking on two session, one of it is called “Architecting GWT applications for production at Google” – maybe it is part two of his last talk on gwt architectures best practices.

I surely won’t miss any of those:

Architecting for performance with Google Web Toolkit

Modern web applications are quickly evolving to an architecture that has to account for the performance characteristics of the client, the server, and the global network connecting them. Should you render HTML on the server or build DOM structures with JS in the browser, or both? This session discusses this, as well as several other key architectural considerations to keep in mind when building your Next Big Thing.

GWT + HTML5 can do what?!

How can you take advantage of new HTML5 features in your GWT applications? In this session, we answer that question in the form of demos — lots and lots of demos. We’ll cover examples of how to use Canvas for advanced graphics, CSS3 features, Web Workers, and more within your GWT applications.

GWT’s UI overhaul: UiBinder, ClientBundle, and Layout Panels

There have been some really huge improvements in GWT’s UI fundamentals over the past year. We’ve introduced features such as UiBinder, ClientBundle, CssResource, and uber layout panels that allow you to build fast UIs in a sane manner. Come see how fun/easy/fast it can be to use these technologies in harmony to overhaul your UI.

GWT continuous build and testing best practices

GWT has a lot of little-publicized infrastructure that can help you build apps The Right Way: test-driven development, fast continuous builds, code coverage, comprehensive unit tests, and integration testing using Selenium or WebDriver. This session will survey GWT’s testing infrastructure, describe some best practices we’ve developed at Google, and help you avoid common pitfalls.

Architecting GWT applications for production at Google

For large GWT applications, there’s a lot you should think about early in the design of your project. GWT has a variety of technologies to help you, but putting it all together can be daunting. This session walks you through how teams at Google architect production-grade apps, from design to deployment, using GWT.

Measure in milliseconds redux: Meet Speed Tracer

It turns out that web apps can be slow for all sorts of opaque and unintuitive reasons. Don’t be fooled into thinking that bloated, slow JavaScript is the only culprit. This session introduces you to Speed Tracer, a new GWT tool that can tell you exactly where time is going within the browser.

Faster apps faster: Optimizing apps with the GWT Compiler

The GWT compiler isn’t just a Java to JavaScript transliterator. It performs many optimizations along the way. In this session, we’ll show you not only the optimizations performed, but how you can get more out of the compiler itself. Learn how to speed up compiles, use -draftCompile, compile for only one locale/browser permutation, and more.

GWT Linkers target HTML5 Web Workers, Chrome Extensions, and more

At its core GWT has a well-defined and customizable mechanism — called Linkers — that controls exactly how GWT’s compiled JavaScript should be packaged, served, and run. This session will describe how to create linkers and explains some of the linkers we’ve created, including a linker that turns a GWT module into an HTML5 Web Worker and one that generates an HTML App Cache manifest automatically.

Hi guys,

We are announcing our end of life of Atlassian support for Internet Explorer 6 on JIRA.

This will be effective from the launch date of JIRA 4.2 (target Q3, 2010). This means that JIRA 4.1 will [...]]]> I found this one here in the atlassian forums, unfortunately the link posted there is broken.

Hi guys,

We are announcing our end of life of Atlassian support for Internet Explorer 6 on JIRA.

This will be effective from the launch date of JIRA 4.2 (target Q3, 2010). This means that JIRA 4.1 will be the last version of JIRA to support IE6. (From JIRA 4.0 to JIRA 4.1, all of the main functionality will work in IE 6; however, some of the visual effects will be missing).

The End of Support Announcements for JIRA specifies end of support for browsers, appserver and JDK. We should add Atlassian products to the IE death march.

13-Jul-2010 Internet Explorer 7 on Windows XP Professional Service Internet Explorer 6 on Windows XP Professional

Aus den “release notes“:

Source: http://geekandpoke.typepad.com/geekandpoke/2009/12/from-hype-to-hype.html

Erster Platz

GOTT IST ALT… ABER VIEL BESCHÄFTIGT! Plakatwettbewerb zum Thema „Generation 50+ und Arbeit“

gratulieren. Lohrey habe ich unter anderem mein Logo zu verdanken.