I’ve come up with a few possible solutions. To start, you could just skip the auto-focus code all together and let your users manually select the input they want to type in.  This can be fine, but in my opinion, what separates good UI from great UI is when the system seems to know what you want and is one step ahead of you. So how can we avoid the problem while still providing the functionality?

Update: Latest Technique

Commenter Joe points out that all three of these techniques fail if you use your browser’s autocomplete to pre-populate the field, but want the web page to focus on the field so you can either hit return or enter a custom username. To handle this scenario I’ve come up with a new recommendation based on focus rather than content:

<script type="text/javascript">
$(document).ready(function() {
	var el = $('#query')[0];
	if (true !== el.hadFocus) {
		el.focus();
	}
});
</script>
<input type="text" onfocus="this.hadFocus = true;" id="query" />

So now, instead of checking to see if there’s any content in the “query” field, we’re checking to see if the user has focused on it. If they haven’t, it’s safe to change the focus there. If they have, you know they’re ahead of your code, and you can just get out of the way.

You might want to expand this to check if any field has been focused on. That way if someone starts typing in your search box, you don’t accidentally send them to the username field. But in general, something like the code above should be good in most situations.

Let me know if you see any potential problems.

Here are the approaches I’ve toyed with.

Option 1: Inline JavaScript

<input id="username" name="username" type="text" />
<script type="text/javascript">
<![CDATA[
if (document.getElementById)
     document.getElementById('username').focus();
]]>
</script>

In simple situations (where the web app uses little to no other javascript), this is the option I go with. But it assumes a modern browser is available.  And while you could use a Javascript framework to support more browsers, then you’d have the associated lag from loading the framework, which could reintroduce the original problem.  That leads me to option 2…

Option 2: Check Before Focus

window.addEvent('domready', function() {
	var field = $('username');
	if (field.value.length == 0) field.focus();
});

In this scenario, you run your auto-focus code once your framework (in this case mootools) and the DOM have loaded, but you check to see if the field has been typed in first.  That way, if I type faster than your CDN loads, the code just doesn’t run.  If you’re using a javascript framework, this is probably the best option.

There’s one other approach that I’ve always thought was interesting, but really doesn’t work in the end.  I’m just putting it here for the fun of it…

Option 3: Make Them Wait

First, output a disabled form element via javascript:

document.write('<input id="username" disabled="disabled" name="username" type="text" />');

Then, output an enabled element in noscript tags (just in case):

<noscript>
<input type="text" name="username" id="username" />
</noscript>

And finally, run your code on DOM Ready:

window.addEvent('domready', function() {
	var field = $('username');
	field.disabled = false;
	field.focus();
});

This way the input is disabled until your code loads. Though technically that method would work, it’s more likely to frustrate your power-users than enhance their user experience.

Have other people experienced this frustration? If you’re a web developer, are there other ways you have dealt with it? Leave a reply, or reply to @inxilpro on twitter.

I just recently started using Twitter, and so far I like it a lot more than I ever thought I would.  This is a problem, though, because I now use it enough to be very frustrated with its faults.  Obviously their scaling problems are an issue that many, many people have talked about, and there are a number of core changes that might make the service better (location-based tweets, additional tweet “types,” etc).  But I’m not talking about anything so grandiose—these are just two simple changes to the UI that would make me very happy.

1. Show Where I Left Off

Every time I refresh my twitter home page, I have to scroll down and find where I left off.  Wouldn’t it be nice if twitter remembered that for you and added a nice little separator in your timeline?  It’s a very simple interface tweak, but could save you a few seconds each time you check twitter.

2. Highlight Replies

Often, even after I’ve found the last tweet I’ve seen, I don’t have time to read through everything posted since then, so I skim.  Normally I’m looking for conversations that I’m either watching or a part of, or I’m looking for replies to my tweets.  Now conversations/threading is an issue that goes into the “bigger problem” category (an issue that Plurk has solved nicely, by the way), but showing replies should be easy as pie.  If a tweet has @inxilpro in it, just highlight it or use some icon to differentiate it.

Solution: Greasemonkey?

I realize that both of these UI changes could be solved with a little Greasemonkey script.  In fact, I plan on writing such a script when I have a spare moment (hah!).  I also realize that both these problems are solved by a number of Twitter clients out there, so maybe I’ll give Twitterific another chance.