NeoTelos.com scores quite well in speed results. 
http://www.vertain.com/m.q?req=cstr&reqid=d9.ABnsE
http://www.webslug.info/index/view/id/2065/neotelos.com
I hope getting some extra recognition for load time of a Web 2.0 page will really get my framework out there!
AJAx Framework released, new domain, new host…many updates!
Stay tuned for a new blog opening! 
HiJackThis
http://www.trendsecure.com/portal/en-US/threat_analytics/hijackthis.php
StartUpList
http://www.merijn.org/files/startuplist.zip
Process Explorer
http://download.sysinternals.com/Files/ProcessExplorer.zip
LSPFix
http://www.cexx.org/lspfix.zip
RegToy
http://kynam.us.to/downloads/regtoysetup.zip
Use at your own risk! Now good luck tweaking!
Opera 9.5 Beta
http://dromaeo.com/?id=2593
FF3 Nightly
http://dromaeo.com/?id=2614
Safari 3.1
http://dromaeo.com/?id=2616
WinGogi Acid3
http://dromaeo.com/?id=3424
WebKit Nightly
http://dromaeo.com/?id=6886
Looks like WebKit wins this round, I can only wait until the next offcial release of Firefox and Safari!
Many awe in fascination of “comet” AJAX applications. Numerous developers drool over how to perform cross-browser support for this feature, while Firefox seems to be the only browser that natively supports it.
Currently, multi-part “comet” AJAX doesn’t seem likely to become mainstream any time soon, mainly due to lack of support. The only feasible solution…long polling. While long polling isn’t the same as multi-part AJAX, there is very little difference. Multi-part AJAX would be more eifficient in many cases, considering the connection does not close until the application is finalized, but the actual overhead saved is minuscule when considering the drawbacks. Long polling allows the application to send a poll request, but finish the poll as the data needs to be sent. This simulates a result similar to multi-part AJAX, without the compatibility issues.
After doing some research, I found some amazing information.
Since few have actually figured it out, I had to piece it together myself. Many people sit in awe when viewing ccertain websites such as Meebo.com, wondering how the actually accomplish AJAX-push with cross-browser support. The whole concept, in actuality, is quite simple…long polling!
Some of you may have heard of long polling before, but the concept isn’t always understood. You can use a regular ajax framework and re-write the server-side scripting in a way that the polling isn’t finished being sent until the data has changed. This is a similar concept to XSS (cross-site scripting) using frames.
Now knowing the truth, I hope to have some working examples of this concept up in a few weeks.
It seems multipart ajax is quite new in development, while it *is* fully supported by Firefox, there is no common support for Internet Explorer. There are other methods using iframe objects or the MS DOMDocument object.
Although iframes provide a simple solution, problems with overloading the DOM should be noted. A data is sent through the iframe, it will begin to accumulate over time. This can create a temporary “memory leak” effect on the client, thus the iframe should be periodically cleared.
The other solution is to use a combination of xmlhttp and the DOMDocument object. While DOMDocument may work in Internet Explorer, it is not fully supported under other plaforms. The DOMDocument object allows Internet Explorer to recieve and process “chunks” of data as they are recieved, this is the same effect that the xmlhttp object gives with multipart enabled. More information on the DOMDocument object can be found on the Microsoft Support website.
Although Firefox has long been the more stable platform for web design, AJAX scripting can be quite buggy. I have found that while Firefox suspports newer AJAX methods natively than Internet Explorer (such as COMET PUSH), Internet Explorer has far less quirks which may cause problems for Firefox users if your pages are not coded properly.
Quirk #1: onreadystatechange
The onreadeaystatechange action is one of the most vital methods to AJAX scripting, while Firefox and many other mainstream browsers support the onload method, Internet Explorer does not. This action also provides much more control as the onload method is only invoked when the transaction is complete. I have found that setting this option before using the send command can invoke exception errors. Although some may be weary of setting this action before sending an AJAX command to the server, it will not make a major impact on your code. The most this will do is prevent the onreadystatechange from exceuting when the readystate of the xmlhttp object is 1.
This method of coding will solve this rare bug in Firefox:
xmlhttp.open(’GET’,URL);
xmlhttp.send();
xmlhttp.onreadystatechange = processData;
More information about the readystate property can be found here.
Quirk #2: setRequestHeader
The setRequestHeader method is often used to set mime types for form data using when using the “POST” method when sending data. This has been found sometimes create an exception and can be solved by using the try block. This method must ALWAYS be called after the connection has been opened and before the data has been sent. This method will also fail if the readystate of the xmlhttp object is not equivalent to 1.
Here is a very simple way of solving this problem:
try {
xmlhttp.setRequestHeader(”Content-type”, “application/x-www-form-urlencoded”);
} catch(e) {
// Try to recreate xmlhttp object and retry
// You can also check if the xmlhttp object’s readystate is equal to 1 to attempt to prevent from having to recreate the xmlhttp object
}
Quirk #3: To be continued…
To be continued….
Many people struggle with the idea of IE7 and cross-browser compatability. This can easilty be solved by implementing the try statement in your code.
While Firefox natively supports xmlhttp through the DOM, the xmlhttp object can easily be created with the following statement:
xmlhttp = new XMLHttpRequest();
Internet Explorer and many other platforms do not have the xmlhttp object fully implemented into the DOM. Versions 6 and 7 of Internet Explorer support the following:
xmlhttp = new ActiveXObject(”Msxml2.XMLHTTP”);
Although most current browsers will support a conjuction of the two methods, the following method had been more commonly used:
xmlhttp = new ActiveXObject(”Microsoft.XMLHTTP”);
Including the method as shown should be considered the proper way to invoke the creation of the the xmlhttp object. These methods can be combined together using the try block.
var xmlhttp;
try {
xmlhttp = new XMLHttpRequest();
} catch(e) {
try {
xmlhttp = new ActiveXObject(”Msxml2.XMLHTTP”);
} catch(e) {
try {
xmlhttp = new ActiveXObject(”Microsoft.XMLHTTP”);
} catch(e) {
alert(’Error: Could not create AJAX Interface.’);
}
}
}
As seen above, this method will first attempt to use native support, then try to create the object using alternate methods if it fails.
I just finished configuring my blog, and now it’s ready for use.