Showing posts with label Web Engineering/Performance. Show all posts
Showing posts with label Web Engineering/Performance. Show all posts

Google Web Toolkit (GWT)....official release version 1.5  

GWT released officially the final version 1.5 today. Congrats to the GWT team and the whole community for making this release happen.

What for developers?
With Google Web Toolkit (GWT), you write your AJAX front-end in the Java programming language which GWT then cross-compiles into optimized JavaScript that automatically works across all major browsers. During development, you can iterate quickly in the same "edit - refesh - view" cycle you're accustomed to with JavaScript, with the added benefit of being able to debug and step through your Java code line by line. When you're ready to deploy, GWT compiles your Java source code into optimized, standalone JavaScript files. Easily build one widget for an existing web page or an entire application using Google Web Toolkit.

The main new features :
  • Support Java 5 language and enhanced JRE emulation
  • Performance optimizations and easier JavaScript interop
  • Prettier widgets, better DOM and accessibility, and bi-directional
Read more on GWT product review.

Development Tools
GWT uses Java, you can use all of your favorite Java development tools (Eclipse, IntelliJ, JProfiler, JUnit) for your AJAX development.

Read more further information on GWT blog.

Read More...
AddThis Social Bookmark Button

Keynote KITE Program  


If you want to know how your website run and measure the performance metrics, Keynote(KITE) early adopter program is for you. It services for measuring web site availability and performance, and able to specify when and how often to run the scripts. Here, KITE works:-
  1. Download your free copy of KITE and register for full access to Keynote's Global Network.

  2. Navigate through areas of your web application that you want to test and measure. KITE will record them easily for you.

  3. Test your Web application from your desktop and review the performance metrics.

  4. Choose the measurement locations on Keynote's Global Network. Get and compare the performance results for your applications globally. That's it. You're done.

And Steve Souders got an early look at KITE program and said some of features:-
  • Test scripts can include taking actions based on DOM events, such as the creation of a DOM element or even the contents of a DOM element matching a specified pattern.
  • An intuitive HTTP profile is displayed in the client app.
  • Tests can be executed at five cities worldwide on the Keynote backbone.

Read More...
AddThis Social Bookmark Button

Gaia Glory Beta 3.0 Library Released  

Gaia Ajax Widgets is an Open Source Ajax Framework for Microsoft ASP.NET or Mono.



Gaia has done nicely job for Ajax framework with ASP.Net and released Gaia Glory Beta 3 toolkit library. Highlight of samples are following:
Tree View
Grid view
Portal Example
Dynamic Image
Controls Madness
Complex Controls Mixed



There are plenty of other samples in Gaia site and as developers alike, Gaia Ajax widgets is published under a pure GPL version 2 license that you can develop the open source software. Those whose are interested developing in commercial software, buying the License which does not restrict your source code into being open source.

Check the other samples and latest development here.

Read More...
AddThis Social Bookmark Button

Testing Website with Different IE Versions  

I just found a nice little tool for testing the web sites on different versions of Internet Explorer (IE). There have always been difficult, running to different versions of the browser in Window due to prevent from Microsoft and some of solutions could get around this limitation but often happened unexpected results and instability for OS or required you to run a VM.

Anyway, here is a free tool called IETester from Jean-Fabrice RABAUTE, whose behind the IE debugger DebugBar. This tool allows you to have the rendering and JavaScript engines of IE8 beta 1, IE7 IE6 and IE5.5 on Vista and XP, as well as the installed IE in the same process.



See the screencast on testing IETester below.


Read More...
AddThis Social Bookmark Button

Using Popular Ajax Libraries on Google  

Today, Google announced the Hosting Ajax Libraries API for the developers whose are using any of the popular JavaScript frameworks such as
Using the libraries from Google is that you don't need to worry uploading those files to a site or difficult to manage all the different versions, caching shared JavaScript libraries, and instead performing Web applications faster.
You can see below how to use those libraries from Google.
What exactly is the AJAX Libraries API?

We have worked with a subset of the most popular JavaScript frameworks to host their work on the Google infrastructure. The AJAX Libraries API then becomes a content distribution network and loading architecture for these libraries.
We work with the key stake holders for these libraries to make sure that the latest stable versions of their work get into our system as they are released. Once we host a release of a given library, we are committed to hosting that release indefinitely.

You can access the libraries in two ways, and either way we take the pain out of hosting the libraries, correctly setting cache headers, staying up to date with the most recent bug fixes, etc.

The first way to access the scripts is simply be using a standard tag that points to the correct place.

For example, to load Prototype version 1.6.0.2 you would place the following in your HTML:
<script src="http://ajax.googleapis.com/ajax/libs/prototype/1.6.0.2/prototype.js"></script>

The second way to access the scripts is via the Google AJAX API Loader's google.load() method.

Here is an example using that technique to load and use jQuery for a simple search mashup:
 
<script src="http://ajax.googleapis.com/ajax/libs/prototype/1.6.0.2/prototype.js"></script>

<script src="http://www.google.com/jsapi"></script>
<script>
// Load jQuery
google.load("jquery", "1");

// on page load complete, fire off a jQuery json-p query
// against Google web search
google.setOnLoadCallback(function() {
$.getJSON("http://ajax.googleapis.com/ajax/services/search/web?q=google&;v=1.0&;callback=?",

// on search completion, process the results
function (data) {
if (data.responseDate.results &&
data.responseDate.results.length>0) {
renderResults(data.responseDate.results);
}
});
});
</script>

You will notice that the version used was just "1". This is a smart versioning feature that allows your application to specify a desired version with as much precision as it needs. By dropping version fields, you end up wild carding a field. For instance, consider a set of versions: 1.9.1, 1.8.4, 1.8.2.

Specifying a version of "1.8.2" will select the obvious version. This is because a fully specified version was used. Specifying a version of "1.8" would select version 1.8.4 since this is the highest versioned release in the 1.8 branch. For much the same reason, a request for "1" will end up loading version 1.9.1.

Note, these versioning semantics work the same way when using google.load and when using direct script urls.

By default, the JavaScript that gets sent back by the loader will be minified, if there is a version supported. Thus, for the example above we would return the minified version of jQuery. If you specifically want the raw JavaScript itself, you can add the "uncompressed" parameter like so:
 
google.load("jquery", "1.2", {uncompressed:true});

Today we are starting with the current versions of the library, but moving forward we will be archiving all versions from now onwards so you can be sure they are available.

For a full listing of the currently supported libraries, see the documentation.


Read More...
AddThis Social Bookmark Button

Cuzillion wtih High Performance on Web  

Steve Souders released a new open source tool called Cuzillion, at Web 2.0 Expo. The tool is for constructing web pages to see how components interact and lets you test out different techniques for optimizing performance in browsers.

So what's Cuzillion behind the idea, he says:
I’m constantly thinking of or being asked about how browsers handle different sets of resources loaded in various ways. Before I would open an editor and build some test pages. Firing up a packet sniffer I would load these pages in different browsers to diagnose what was going on. I was starting my research on advanced techniques for loading scripts without blocking and realized the number of test pages needed to cover all the permutations was in the hundreds. That was the birth of Cuzillion.

He also talks about some examples:
A great example of how Cuzillion is useful is looking at the impact inline scripts have when they follow a stylesheet in Internet Explorer. Typically, a stylesheet followed by any other resource results in both resources being downloaded in parallel in Internet Explorer. (In Firefox stylesheets block parallel downloads, so this performance optimization is only applicable to IE.) Here’s a Cuzillion page that shows this: stylesheet and image downloading in parallel. Both the stylesheet and image are configured to take 2 seconds to download. Since they download in parallel the page takes about 2 seconds to load as shown by the “page load time”.

But look what happens if we put an innocent inline script between the stylesheet and image: stylesheet, inline script, and image. Now, in Internet Explorer the stylesheet and image are downloaded sequentially, which means the page load time goes from 2 seconds to 4 seconds. If the inline script is simply moved above the stylesheet the two resources are downloaded in parallel again, and the page load goes back down to 2 seconds: inline script, stylesheet, and image.

This was a great discovery. But immediately my officemate asked if inline style blocks had the same effect. No problem. With Cuzillion I just do some clicks and drag-and-drop, and can test it out: stylesheet, inline style block, image. It turns out inline style blocks don’t cause stylesheets to block downloads.

The findings from a tool like Cuzillion are really valuable. The lessons learned from poking at inline scripts and stylesheets can save hundreds of milliseconds on page load times. And it’s a common problem. eBay, MSN.com, MySpace, and Wikipedia all suffer from this problem.

Much thanks to Google for letting me release this code under Open Source. It’s not currently on Google Code but if you want to contribute let me know and I’ll do that. Try it out and send me your feedback. And share your insights with others. We all want the Internet to be faster!

Here is Steve's interview about Cuzillion screencast.


You can find out Cuzillion more about information and the future works at Stevesouders.com/cuzzillon.

Read More...
AddThis Social Bookmark Button