Today you can use a Comet technique (in particular, Ajax with long polling) which is available in all browsers. Using this concept, the browser makes a standard AJAX call to the server that waits until it receives a message. Asynchronous Pages and Asynchronous Controller allow you to have long running HTTP requests without using precious ASP.Net threads.

On the server, there are two resource limits to consider with IIS and ASP.Net:

• HTTP request limits — in IIS7 the default limit is 5000
• ASP.Net thread limits — in IIS7 the default limit is 12 x number of CPUs

For a typical ASP.Net application (and ASP.Net MVC application), an HTTP request always uses an ASP.Net thread. However you can use Asynchronous Pages in ASP.Net or Asyncronous Controllers in ASP.Net MVC to free the ASP.Net thread (but still keep the HTTP request). Using Asynchronous Pages or Controllers is ideal for Comet HTTP requests.

Take for example an email web application that has jQuery code to check for new mail. It calls /CheckEmail which returns either true or false. As soon as it completes it calls checkEmail() immediately so that it can be notified of any new mail.

        $(function () {
            checkEmail();
        });

        function checkEmail() {
            $.post("/CheckEmail", null, function (data, s) {
                if (data.d) {
                    $('#emailCheck').text('You have mail!');
                } else {
                    $('#emailCheck').text('No change.');
                }

                checkEmail();
            });
        }

On the server, the code uses the AsyncController to free the ASP.Net thread for other HTTP requests until this HTTP request has completed.

    public class CheckEmailController : AsyncController
    {
        //
        // GET: /CheckEmail/

        public void IndexAsync()
        {
            AsyncManager.OutstandingOperations.Increment();
            MyAsyncEmailChecker.CheckForEmailAsync(hasEmail =>
            {
                AsyncManager.Parameters["hasEmail"] = hasEmail;
                AsyncManager.OutstandingOperations.Decrement();
            });
        }

        private class IndexResponse
        {
            public bool d { get; set; }
        }

        public JsonResult IndexCompleted(bool hasEmail)
        {
            return this.Json(new IndexResponse() { d = hasEmail });
        }

    }

There are three phases on the server.

        public void IndexAsync()
        {
            AsyncManager.OutstandingOperations.Increment();
            MyAsyncEmailChecker.CheckForEmailAsync(/* callback function */);
        }

The first phase calls AsyncManager.OutstandingOperations.Increment() and MyAsyncEmailChecker.CheckForEmailAsync. When AsyncManager.OutstandingOperations is zero, the matching “Completed” method is called. This increment prevents the Completed method from being called before the data is ready. Next the code initiates an Async call to MyAsyncEmailChecker.CheckForEmailAsync(). This is a method I wrote, and in fact it just a demo class for this article. It returns immediately and then calls the callback function 5 seconds later. “Async” functions are common in the .Net framework, for example:

• MessageQueue.BeginReceive
• Asynchronous Webservice calls
• Socket.BeginSend

            /* an Async function */(hasEmail =>
            {
                AsyncManager.Parameters["hasEmail"] = hasEmail;
                AsyncManager.OutstandingOperations.Decrement();
            })

The next phase calls the function passed in when the MyAsyncEmailChecker finishes. It sets the return data in the AsyncManager.Parameters collection. These are the same parameters found in the IndexCompleted method. Next the code calls AsyncManager.OutstandingOperations.Decrement(). Now that AsyncManager.OutstandingOperations is zero, ASP.Net MVC will call IndexCompleted().

        public JsonResult IndexCompleted(bool hasEmail)
        {
            return this.Json(new IndexResponse() { d = hasEmail });
        }

The IndexCompleted method returns the data to the browser — in this case it is a JsonResult.

Lastly, most browsers limit 2 HTTP connections to the same server, though recent browsers do not have this limitation. If the browser has a long running HTTP connection to recent messages from the server, it is using one of your two HTTP connections.

UPDATE 2011-05-20: You can download the full source code here.

SQL Server Compressed Backup will back up SQL Server databases using either gzip, zip or bzip2 compression.

The new features are:

• Fixed the encoding problem by removing “\s”, “\p” and “\\” since they are commonly used in file paths and replacing them with “;;” to mean “;”. Looking at the command line options, it is only necessary to encode the semicolon, so “;;” is the only encoding the command line does.
• Added a feature I’ve personally wanted: progress updates and an estimated time until completion. It is more verbose at the beginning (every few seconds), then slows down. After an hour of backing up, updates are only once every 24 minutes.
• Worked on the BlockSize and BufferCount request. I’m not keen on implementing BlockSize. I’d like to hear someone explain how they take advantage of it. My understanding is that BlockSize is only for writing to devices (tapes and CD-ROMs — not files on a CD-ROM though), so it doesn’t seem appropriate for backing up to files. BufferCount and MaxTransferSize seem like reasonable options to request, so these are now available.
]]> http://clay.lenharts.net/blog/2009/11/23/sql-server-compressed-backup-v12-released/feed/ 129 http://clay.lenharts.net/blog/2009/05/29/how-ssas-cube-processing-affects-running-queries/ http://clay.lenharts.net/blog/2009/05/29/how-ssas-cube-processing-affects-running-queries/#comments Fri, 29 May 2009 19:26:55 +0000 http://clay.lenharts.net/blog/?p=119 Continue reading →]]> SSAS cube processing can kill running queries. That’s right, it may kill queries in order to commit changes to the cube.

Here is what happens during SSAS cube processing.

1. The cube finishes calculating the next version of the cube
2. Before the data can be made available, SSAS prevents new queries from running
3. Any currently running queries are allowed to finished normally for 30 seconds
4. After 30 seconds, SSAS kills any running queries
5. SSAS commits the new version and allows new queries to hit the updated data

The 30 second time out is a configuration setting that you can read about here.

So, that’s right, SSAS may kill long running queries.

]]> http://clay.lenharts.net/blog/2009/05/29/how-ssas-cube-processing-affects-running-queries/feed/ 11 http://clay.lenharts.net/blog/2009/05/29/execution-plan-of-frequent-queries/ http://clay.lenharts.net/blog/2009/05/29/execution-plan-of-frequent-queries/#comments Fri, 29 May 2009 19:03:42 +0000 http://clay.lenharts.net/blog/?p=110 Continue reading →]]> Bill Galashan, DBA of bet365 sent over the following query that lists the execution plan of the 10 most frequently executed queries.

He writes:

We got into this due to different query plans coming from a VB or a web app than what was seen when running the same query from Management Studio. Eventually tracked this down to a difference in the set options predominatley whether Arithabort was on or off.

Read more to see his query.

Click here to see the execution plan of currently running queries.

SELECT TOP 10 creation_time, last_execution_time,  last_worker_time / 1000 as [Last Worker Time (ms)] ,min_worker_time / 1000 as [Min Worker Time (ms)], 
      max_worker_time / 1000 as [Max Worker Time (ms)],
    total_worker_time/execution_count/1000 AS [Avg Worker Time (ms)],
    execution_count, 
    SUBSTRING(st.text, (qs.statement_start_offset/2) + 1,
    ((CASE statement_end_offset 
        WHEN -1 THEN DATALENGTH(st.text)
        ELSE qs.statement_end_offset 
        END 
            - qs.statement_start_offset)/2) + 1) as statement_text,plan_generation_num ,query_plan, Plan_handle
FROM sys.dm_exec_query_stats as qs
CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) as st
CROSS APPLY sys.dm_exec_query_plan(qs.plan_handle)
-- where st.text like '%proc name to be searched for%'
ORDER BY execution_count DESC;

--- Determine options used at run time

select  * from sys.syscacheobjects with (nolock) where sql like '%proc to be searched for%' and objtype='proc'


select dbo.fn_setopts(249)

/*
 This contains a bitmap containing the SET options relevant to each cached plan for a proc.
The following function can be used to decipher this bitmask:
*/

 

create function dbo.fn_setopts(@setopts int)
returns nvarchar(4000)

as
begin

declare @s nvarchar(4000)
select @s='Options: '
if @setopts & 1    > 0 select @s = @s + N'ANSI_PADDING, ' 
if @setopts & 2    > 0 select @s = @s + N'max degree of parallelism, '
if @setopts & 4    > 0 select @s = @s + N'FORCEPLAN, ' 
if @setopts & 8    > 0 select @s = @s + N'CONCAT_NULL_YIELDS_NULL, '
if @setopts & 16   > 0 select @s = @s + N'ANSI_WARNINGS, '
if @setopts & 32   > 0 select @s = @s + N'ANSI_NULLS, '
if @setopts & 64   > 0 select @s = @s + N'QUOTED_IDENTIFIER, '
if @setopts & 128  > 0 select @s = @s + N'ANSI_NULL_DFLT_ON, '
if @setopts & 256  > 0 select @s = @s + N'ANSI_NULL_DFLT_OFF, '
if @setopts & 512  > 0 select @s = @s + N'NO_BROWSETABLE, '
if @setopts & 1024 > 0 select @s = @s + N'TriggerOneRow, '
if @setopts & 2048 > 0 select @s = @s + N'ResyncQuery, '
if @setopts & 4096 > 0 select @s = @s + N'ARITHABORT, '
if @setopts & 8192 > 0 select @s = @s + N'NUMERIC_ROUNDABORT, ' 

return @s

end

]]> http://clay.lenharts.net/blog/2009/05/29/execution-plan-of-frequent-queries/feed/ 28 http://clay.lenharts.net/blog/2009/05/25/gwt-is-flexible-iphone-demo/ http://clay.lenharts.net/blog/2009/05/25/gwt-is-flexible-iphone-demo/#comments Mon, 25 May 2009 14:36:30 +0000 http://clay.lenharts.net/blog/?p=57 Continue reading →]]> GWT is a very flexible environment that allows you to write a web application in Java and compile it to Javascript — even for the iPhone.

A number of people have fears with GWT, for instance

• (not true) GWT isn’t flexible which will lead developers down a dead-end path.
• (not true) GWT is ugly, and can’t be used to make “gucci” UIs.

This post will show that these are just myths.

Demos

First, lets take a look at the demo.  Below is a re-write of Apple’s “Simple Browser” demo using GWT.  You can find the original demo here: https://developer.apple.com/webapps/docs/referencelibrary/index-date.html (search on the page for “simple browser”).

You can try the GWT version of the demo on the iPhone: live GWT demo, and the source code which includes the source control history.

or compare it to the original Apple demo

For those who don’t have an iPhone, here is a quick video of the demo written in GWT:

GWT is Flexible

The iPhone provides several unique challenges to GWT:

• iPhone has specific events like orientation change, touch, and transition end events
• iPhone has specific animation features to slide from one “page” to the next (Page, in the demo, is conceptual.  Once the app is loaded, it never goes to another HTML page.)
• The built-in GWT controls prefer tags like <div> and <table>.  We want to use other HTML tags such as <ul> and <li> in the iPhone

GWT manages events, with good reason. By managing events, GWT prevents a whole class of memory leaks. So implementing events that GWT is unaware of is not ideal. The demo handles this by either firing event on objects that will always exist in the application, or adding or remove events when the control is added or removed from the DOM using the onLoad() and onUnload() methods.

The GWT demo wires up the iPhone specific events by calling native JSNI method. In native methods you write any Javascript you want, but you have the added risk of memory leaks. This method wires up the screen orientation change event:

	private native void registerOrientationChangedHandler(
			OrientationChangedDomEvent handler) /*-{
		var callback = function(){
			handler.@net.lenharts.gwt.sampleiphoneapp.client.model.Screen$OrientationChangedDomEvent::onOrientationChanged()();
		}

		$wnd.addEventListener("orientationchange", callback, false);
	}-*/;

When the screen orientation changes, the handler.@net.lenharts.gwt.sampleiphoneapp.client.model.Screen$OrientationChangedDomEvent::onOrientationChanged()() method is called, which is a special GWT notation allow you to call Java methods from Javascript. When the code is compiled to Javascript, this will be replaced with the actual compiled Javascript function.

Animations on the iPhone are surprising easy. In fact animations are included in the CSS 3 specification soon to be released. If you have the Google Chrome 2 browser, you can try out the animations in the link.

To use these animations the pseudo code is

1. Set the content of a element.
2. Set the element to a CSS class that disables animations
3. Set the element to another CSS class that will position the element at the beginning position of the animation (give the element two classes)
4. Schedule a DeferredCommand
5. In the DeferredCommand, remove the CSS classes set above and set the element to a CSS class that enables animations.
6. Then set the element to a CSS class to position the element at the destination position. (again keeping the animation class).
7. When the transition ends (using the transitionend event), disable animations by removing the CSS class that enables animations and replace it with the CSS class to disable animations.

GWT allows you to create any type of element within the <body> tag. The default set of widgets, unfortunately, do not give you every tag, so you have to write your own class. Luckily you only need two classes to create any element: one class for elements that contain text, and one class for elements that contain other elements.

Here is the class that contains other elements:

package net.lenharts.gwt.sampleiphoneapp.client.util;

import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.ui.*;

public class GenericContainerTag extends ComplexPanel {
	public GenericContainerTag(String tagName) {
		setElement(DOM.createElement(tagName));
	}

	/**
	 * Adds a new child widget to the panel.
	 * 
	 * @param w
	 *            the widget to be added
	 */
	@Override
	public void add(Widget w) {
		add(w, getElement());
	}

	/**
	 * Inserts a widget before the specified index.
	 * 
	 * @param w
	 *            the widget to be inserted
	 * @param beforeIndex
	 *            the index before which it will be inserted
	 * @throws IndexOutOfBoundsException
	 *             if <code>beforeIndex</code> is out of range
	 */
	public void insert(Widget w, int beforeIndex) {
		insert(w, getElement(), beforeIndex, true);
	}
}

To create the element, you pass in the name of the tag. For instance, if you want to create a <ul> tag, you create it like so

GenericContainerTag ul = new GenericContainerTag("ul");

The class for elements that contain text is a bit more complicated, especially since we’re enabling iPhone specific events here. If you were to take out the event code, you’d find this to be much smaller. Plus it tries to wire touch events for the iPhone, and click events for all other browsers. For now, don’t worry about the details, let’s just skip down to how to create it.

package net.lenharts.gwt.sampleiphoneapp.client.util;

//based on Label.java source code that comes with GWT

import com.google.gwt.user.client.ui.*;
import com.google.gwt.dom.client.Document;
import com.google.gwt.dom.client.Element;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.shared.GwtEvent;
import com.google.gwt.event.shared.HandlerRegistration;

public class GenericTextTag<E> extends Widget implements HasText {

	private boolean mMovedAfterTouch = false;
	private E mAttachedInfo;

	private boolean mWantsEvents = false;
	private boolean mEventsWiredUp = false;
	HandlerRegistration mHandlerRegistration;

	public GenericTextTag(String tagName) {
		setElement(Document.get().createElement(tagName));
	}

	@Override
	protected void onLoad() {
		if (mWantsEvents) {
			wireUpEvents();
		}
	}

	private void wireUpEvents() {
		if (!mEventsWiredUp && this.isAttached()) {
			if (hasTouchEvent(this.getElement())) {
				registerDomTouchEvents();
			} else {
				// used for debugging:
				mHandlerRegistration = this.addDomHandler(new ClickHandler() {
					@Override
					public void onClick(ClickEvent event) {
						event.preventDefault();
						fireTouchClick();
					}
				}, ClickEvent.getType());
			}
			mEventsWiredUp = true;
		}
	}

	private void wireDownEvents() {
		if (mEventsWiredUp) {
			if (hasTouchEvent(this.getElement())) {
				unRegisterDomTouchEvents();
			} else {
				mHandlerRegistration.removeHandler();
			}
		}
		mEventsWiredUp = false;
	}

	@Override
	protected void onUnload() {
		wireDownEvents();
	}

	public GenericTextTag(String tagName, String text) {
		this(tagName);
		setText(text);
	}

	public void setAttachedInfo(E info) {
		mAttachedInfo = info;
	}

	public final HandlerRegistration addHandler(
			final TouchClickEvent.TouchClickHandler<E> handler) {
		if (!mWantsEvents) {
			mWantsEvents = true;
			wireUpEvents();
		}
		return this
				.addHandler(
						handler,
						(GwtEvent.Type<TouchClickEvent.TouchClickHandler<E>>) TouchClickEvent
								.getType());
	}

	public E getAttachedInfo() {
		return mAttachedInfo;
	}

	private native void registerDomTouchEvents() /*-{
		var instance = this;
		var element = this.@net.lenharts.gwt.sampleiphoneapp.client.util.GenericTextTag::getElement()();

		element.ontouchstart = function(e){
				instance.@net.lenharts.gwt.sampleiphoneapp.client.util.GenericTextTag::onDomTouchStart()();
		};

		element.ontouchmove = function(e){
				instance.@net.lenharts.gwt.sampleiphoneapp.client.util.GenericTextTag::onDomTouchMove()();
		};

		element.ontouchend = function(e){
				instance.@net.lenharts.gwt.sampleiphoneapp.client.util.GenericTextTag::onDomTouchEnd()();
		};
	}-*/;

	private native void unRegisterDomTouchEvents() /*-{
		var instance = this;
		var element = this.@net.lenharts.gwt.sampleiphoneapp.client.util.GenericTextTag::getElement()();

		element.ontouchstart = null;

		element.ontouchmove = null;

		element.ontouchend = null;
	}-*/;

	public void onDomTouchStart() {
		mMovedAfterTouch = false;
	}

	public void onDomTouchMove() {
		mMovedAfterTouch = true;
	}

	public void onDomTouchEnd() {
		if (mMovedAfterTouch) {
			return;
		}

		fireTouchClick();
	}

	private void fireTouchClick() {
		fireEvent(new TouchClickEvent<E>(this));
	}

	public String getText() {
		return getElement().getInnerText();
	}

	public void setText(String text) {
		getElement().setInnerText(text);
	}

	private static native boolean hasTouchEvent(Element e) /*-{
		var ua = navigator.userAgent.toLowerCase();

		if (ua.indexOf("safari") != -1 &&
			ua.indexOf("applewebkit") != -1 &&
			ua.indexOf("mobile") != -1) 
		{    	
			return true;
		}
		else 
		{
			return false;
		}
	}-*/;

}

The code below creates an <li> tag that contains the text “Hello World!”. The “Hello World!” test is not fixed. The class has getter and setter methods for changing the text too.

GenericTextTag<String> li = new GenericTextTag<String>("li", "Hello World!");

GWT Does Not Have to be Ugly

As you can see in the examples above, you can create any HTML tag, and you can use any CSS style you like. The sky is the limit on how you style your GWT application. Many people see the GWT examples and they have an “application” feel to it. Granted the built-in widgets encourage this, but as you can see, you are not restricted to their widgets and you can have a more “document” feel to your webpage. You have complete control of the body tag.

Why GWT?

For me, the difference between GWT and Javascript is whether you want to work with a static language like Java, or a dynamic language like Javascript.  I assert, with little proof, that static languages are better.  They provide a much deeper verification of your code which I feel is necessary of any sizable application.  I remember the VBScript days, and I don’t want to return to shipping bugs that are trival to find by a static language compiler.

There are issues with the size of the javascript download that both sides claim to be better.

• Pure Javascript is smaller because you include a library from Google that the user has already downloaded plus your small javascript code that you write
• GWT is smaller, because the GWT compiler is highly optimized to remove dead code and to restructure your code to be as small as possible.  For instance, if you only use 10% of a library, then the downloaded code includes only 10% of the library.

Small apps can work OK with a dynamic language, with the potential that it will have less code to download.  However for larger applications, the GWT compiler will produce smaller code as compared to hand written, minified Javascript and the static language will help reduce the number of bugs.

]]> http://clay.lenharts.net/blog/2009/05/25/gwt-is-flexible-iphone-demo/feed/ 44 http://clay.lenharts.net/blog/2009/03/07/openid-is-great/ http://clay.lenharts.net/blog/2009/03/07/openid-is-great/#comments Sat, 07 Mar 2009 14:49:05 +0000 http://clay.lenharts.net/blog/?p=55 Continue reading →]]> It’s so easy to set up, I can’t believe I haven’t done it before.

All you need is an openid account (like www.myopenid.com, which they seem to like), and a static HTML page.

You don’t really need the static HTML page, but it allows you to switch openid accounts easily.

To login to an openid enabled site, like sourceforge.net, you enter your static HTML page into the openid field, for instance I use http://clay.lenharts.net/openid/. The static HTML page contains some links that point to your real openid account.  After logging in you are done.

]]> http://clay.lenharts.net/blog/2009/03/07/openid-is-great/feed/ 25 http://clay.lenharts.net/blog/2008/10/25/the-many-core-problem/ http://clay.lenharts.net/blog/2008/10/25/the-many-core-problem/#comments Sat, 25 Oct 2008 23:03:31 +0000 http://clay.lenharts.net/blog/?p=43 Continue reading →]]> We, as developers, have a problem.  CPUs will continue to have more cores, and each core is not going to be any faster.  The only way to write faster applications is to write multithreaded code, which has two challenges:
• Multithreaded code is complex to write and think about.
• Multithreaded code is difficult to test.

From what I’ve seen, people are pursuing 4 approaches. 

Better Languages

If languages are the whole answer, the language has to make it impossible to write multithreaded bugs, otherwise you only address the first problem (the complexity).

Erlang is one such language that removes whole class of multithreaded bugs. Erlang’s approach is to isolate the threads, and give them a way to pass messages to each other.  However programming in Erlang is awkward and arguably it makes the code more complex.

Other languages, like Clojure and F#, take a different approach and make it easier to write and deal with multithreaded issues, however they don’t prevent you from writing multithreaded bugs.  These languages do not address the whole problem as you still need a way to test the code.

Better Libraries

Microsoft has a library for .Net called Parallel Task Library to make it easier to write multithreaded code.  Need to operate on each element in an array?  Use the Parallel.For() method.  This library makes it easier to think and write multithreaded code, but it doesn’t make it any easier to test.

Static Code Analyzer

Java has a static code analyzer that is able to find multithreading bugs called FindBugs.  It looks at your code and reports any code that will cause multithreaded bugs.  This would address the second issue, because it, in theory, reports all threading bugs.  It doesn’t however address the first issue, making the code easier to write.

Testing with Deterministic Threads


Microsoft is going in a different direction.  They are working on something called CHESS that makes your unit tests find multithreaded bugs.  It does this by taking over the scheduler and sysmatically repeating each test, weaving the threads differently each time to exercise every possible way the scheduler could run the code.  However it requires us to to write a set of tests that finds *all* the threading bugs.  Since it is common to write unit tests with less than 100% coverage, a code coverage tool should be used to write more tests.

Conclusion

The good news is that there appears to be a variety of approaches to the problem and the whole answer will likely involve a combination of language or library enhancements and analyser or testing enhancements that are already in the works.

]]> http://clay.lenharts.net/blog/2008/10/25/the-many-core-problem/feed/ 21 http://clay.lenharts.net/blog/2008/10/18/functional-language-exploision/ http://clay.lenharts.net/blog/2008/10/18/functional-language-exploision/#comments Sat, 18 Oct 2008 10:50:02 +0000 http://clay.lenharts.net/blog/?p=41 Continue reading →]]> There is suddenly a lot of interest in functional languages recently.  The two advantages are
• Writing a DSL (Domain Specific Language)
• Writing concurrent code

The languages that seem to come up are:

• Clojure (JVM)
• F# (based on OCaml, Haskell, and ML) (.Net CLR)
• Erlang (JVM)

I’m not particularly interested in DSL (despite my last post on code generators), however as CPUs contain more and more cores, we’ll need a way to safely write multithreaded code.

The Clojure project has an interesting post on its approach on simplifying multithreaded code.

Erlang handles concurrency by only having local variables and providing a way to send messages to and from other threads.

Lastly, MPI is a .Net library for distributed processing where the same program executes multiple times and each instance communicates with each other using message passing which sounds very Erlang-like.

]]> http://clay.lenharts.net/blog/2008/10/18/functional-language-exploision/feed/ 12 http://clay.lenharts.net/blog/2008/10/18/gwt-for-web-applications/ http://clay.lenharts.net/blog/2008/10/18/gwt-for-web-applications/#comments Sat, 18 Oct 2008 10:47:01 +0000 http://clay.lenharts.net/blog/?p=42 Continue reading →]]> There are several approaches for writing web applications, each with their own advantages.  GWT is a new framework with its own niche.
• Your standard ASP.Net (or JSP/PHP/etc) w/ Ajax and JQuery (or other Javascript library)
• Java WebStart or .Net ClickOnce
• GWT w/ Webservices


ASP.Net (or JSP/PHP/etc) – for Dynamic Websites


ASP.Net is great, because it will run on any browser, but it difficult and error prone to write Javascript code, and many times the application or site isn’t very interactive or responsive.

A coworker suggests that this is good for a “dynamic website”, rather than a full blown “web application”.  It certainly has a web site feel, rather than an application feel to it.  See the GWT demos below to see what I’m talking about.

Java WebStart or .Net ClickOnce – for Internal Corporate Applications


This, however, provides are great environment for writing interactive applications, however it requires either Java or .Net on the client.  Some users do not have permissions necessary to install Java and .Net.

GWT w/ Webservices – for Public Applications


GWT is a great idea that compiles Java code into Javascript to give you an HTML/Javascript web application.    It allows you to have *a lot* of javascript code that does not talk with the web server.  Be sure to check out these GWT demos.

You can’t use the Java library with GWT, however you get a great GWT UI library, and you can call a webservice to do anything you like, for instance to make database calls.

As a C# developer, I find this great, because the learning curve is small.  The Java language is so close to C#, and I don’t have to learn the Java library.

]]> http://clay.lenharts.net/blog/2008/10/18/gwt-for-web-applications/feed/ 1