Articles by Dietrich Kappe

GWT 1.5 Includes Decent-Looking CSS Themes

Tue, 10 Jun 2008 09:15:00 EDT

One of the welcome developments in GWT 1.5 was the inclusion of some decent looking CSS themes -- standard. chrome and dark. How can you use them in your GWT app? Just include one of the following lines in your apps .xml file. You can see them in action in the ShowCase application. For those of you without the patience to kick start the app, here are some screenshots of the new themes.

AJAXWorld Report: GWT & Java EE – Where Are All of the Alligators?

Sun, 30 Mar 2008 04:30:00 EDT

Just a quick update from the conference (which is now over). I gave my talk at AJAXWorld East 2008 and got some interesting reactions. Met a lot of cool folks, put some faces to names, got to sit on a panel with Douglas Crockford. Cool beans. More next week.

Comet 2008: The State of Play in Reverse AJAX

Mon, 17 Mar 2008 12:45:00 EDT

Just as with advertising measurement for AJAX, I continue to follow the technology known as Comet (open up an HTTP request from browser to server, then keep it open, pushing content down periodically) to see if it is ready for prime time. I thought I'd share my reading list from the last few months.

Yet Another 17 Google Web Toolkit Tutorials

Thu, 07 Feb 2008 12:45:00 EST

Half a year has passed since I published my article 36 GWT Tutorials. As expected, several new tutorials have come along that demonstrate deeper, more sophisticated aspects of the framework, as well as addressing specific IDEs and libraries. I myself am working on a more extensive tutorial to demonstrate porting a Web 1.0 app to GWT. Stay tuned.

Tuning AJAX Applications for Performance

Wed, 16 May 2007 19:00:00 EDT

Performance can have different meanings, depending on your perspective. If you're the end user of an application, performance means that the application is responsive in all circumstances. If you're an application owner or product manager, performance may mean that the application is scalable, i.e., the number of servers you have is directly proportional to the number of users you can handle. In this chapter we're more concerned with the former kind of performance rather than the latter.

Improving Network Performance

Mon, 07 May 2007 04:00:00 EDT

How do we measure the network performance of a Web application? There are a number of tools that can help us measure and diagnose network performance issues, but the best place to start is by taking a look at the initial page, where we load most of the JavaScript, CSS, and images that will be used during the lifetime of the AJAX application.

Real-World AJAX Book Preview: Web Server-Based Compression

Sun, 06 May 2007 11:00:00 EDT

One way of speeding up transfer times of resources between the server and the browser is to reduce the size of the resource being transferred. Practically all modern browsers can receive and decompress compressed content via HTTP. Using one of the HTTP traffic-monitoring tools mentioned above, you can see that browsers send out a header, Accept-Encoding=gzip,deflate, that tells the server that it can get compressed content. For these browsers, you can configure your Web server to compress content on-the-fly for dynamic content and cache compressed versions for static content.

Real-World AJAX Book Preview: JavaScript Profiling

Fri, 04 May 2007 11:00:00 EDT

In some cases you may not know precisely where a performance bottleneck lies. Using our technique of surrounding suspected bottlenecks with timestamps won't work in these cases. We need a way to get a broader overview of application performance. Fortunately there are a number of profiling tools. Unfortunately, they're not standard across browsers.

Real-World AJAX Book Preview: Code Optimization

Thu, 03 May 2007 11:00:00 EDT

Most of the performance optimizations in this section should be familiar to anyone who has performance tuned pre-AJAX JavaScript. In fact, on the client side, the prescription for tuning the code of AJAX applications hasn't changed that much from tuning plain JavaScript: replace expensive operations with less expensive ones; move expensive operations out of inner loops; pre-compute as many values outside of loops as possible; unroll loops where necessary.