



Start Walking
Injected Instrumentation
You can do whatever you want in the site to profile the event you want to capture. You can see the instrumented code based on the performance policy injected into the blog site code. AjaxView injects necessary code for performing profiling, logging an send it to AjaxView at the head of the page.
<head profile=”http://gmpg.org/xfn/11″>
<script>
var PageLoadStart = new Date().getTime();
// other var declarations
var emk_OkToSendNextLog = true;
var verbose = false;
function emk_CheckLogs() {
if( emk_LogRecords.length >= emk_MAX_LOG_RECORDS_BEFORE_FLUSH ) {
emk_FlushLogs();
}
}
function emk_FlushLogs() {
// implementation
}
// other functions
</script>
</head>
<!– actual page code –>
Whereever required, it injects the profile code like the following
(tmpCache_emk_LogRecords.push(‘\r\nLM:PerformancePolicy:PerformancePolicy:SCRIPTENTER,’),
tmpCache_emk_LogRecords.push(new Date().getTime()),
During the loading and other execution of your web application, the above profile codes send the log details back to AjaxView using XMLHttpRequest. See the following figure.

AjaxView Console
Getting the Results
Enough logging, now let us see the analyzed results of the logs by opening new tab in FireFox and type http://fakeurl.com/?&AJAXVIEWREQUEST=GET=main.html. This is a fake URL for getting analyzed reports from AjaxView proxy. A two column page will appear. The left side contains the following links:
Our focus in on JS Performance Statistics.
JS Performance Statistics
When clicking on JS Performance Statistics link, JavaScript related performance statistics will appear on the right side. The result is in a three column tabular, with following items:
In my blog web site, http://fakeurl.com//PerformancePolicy/PerformancePolicy/1646706643?&AJAXVIEWREQUEST=LMINFO shows slowest performance of 164 milliseconds. By clicking the file displays another tabular results which contains number of JavaScript functions in the selected page. Meantime (ms) for the function at http://udooz.net/blog/wp-includes/js/jquery/jquery.js?ver=1.2.6 actually shows lowest performance function with line and column details. Here, it is 164 millisecond. By clicking this shows the actual code.
Comparison with IE Development ToolBar Profiler
Let us verify the results with IE Development ToolBar’s JavaScript profiler. The profiler shows the same set of functions with correct count details also. But it varies in the time. The highest maximum time was 109.38 taken by three functions.




Forces
SolutionWe are doing performance engineering of our web based product and now we are more concentrated on client side performance improvements. With the help of available toolset like Fiddler, IE Development Toolbar and some others, it is possible to tweak the code points based on download time and size of the critical ASPX pages. In addition to this, We would like to know the browser rendering or loading time of a behavior, however none of the tools do not provide such clarity. IE Development Toolbar enables to profile JavaScript but in an ad-hoc manner. I was googled various places, and failed to get such tool. I finished my journey at Microsoft Research where I found a tool called “AjaxView”, which enables to inject instrumentation code such as performance profiling, infinite loop detection, etc on the fly even in the production environment by the following nature of web applications:
Thanks to Emre Kiciman and Benjamin Livshits at Microsoft Research for implementing this great tool.
How Does It Works
AjaxView sits between the web server and clients, acts as server-side proxy. It intercepts and rewrites the JavaScript code generated from the web server for a web request by a client. It does not affect the production (or development) environment. See the following figure.

AjaxView Platform

AjaxView Components
AjaxView supports the following broad categories of instrumentation policies:
Let us see a practical walk-through on the next post for better understanding of this tool.
References




Microsoft released Internet Explorer 8.0 a couple of days before. When I installed RC1 months before, I had experienced some page crashes and degrade in performance and usability. The most critical thing was loading “about:Tab” / “about:blank”.
The final release of IE 8.0 is impressed me lot not only for its performance and usability (of course, it is much faster than Chrome), its compliance with the industry standard and moving twoards the semantic web. As a developer, it enables to write our web applications much standard way. In addition to this, the IE 8.0 readiness toolkit enables to add new face to your web application. From the compatibility perspective, it has three different rendering modes:
Let us see the IE 8.0’s new features and standards from developer view point.
Web Standards
CSS Expression has been deprecated in IE 8.0 (standard mode) due to its non-standard CSS extension and performane issue. However, numerous non-CSS 2.1 properties are introduced with “-ms” prefix. The filters also non-standard CSS, so they are now with “-ms” prefix.
<img src=data:image/gif;base64, XyVRKzw0CClkeqva…
AJAX now in HTML 5 Standard
var globalStorage = window.globalStorage["http://www.udooz.net"];
or
var sessionStorage = window.sessionStorage["http://www.udooz.net"];
// to check browser offline
if(!window.navigator.onLine) // do offline behavior
Cross-domain Communication
window.postMessage(“Cross-domain communicated”, “http://www.msn.co.in”);
Visit http://msdn.microsoft.com/en-au/ie/dd433173.aspx#AJAX for more details.
Native JSON Support
IE 8.0 uses douglas crockford’s JSON API, so that you can natively call JSON.stringfy() and JSON.parse() methods.
In addition these, there are so many other features which makes IE 8.0 more near to the semantic web arena. I’ll cover those details in a separate post.




Problem
Consume the application logic from presentation tier with domain entities those are specialized for this tier with minimal plumbing.
Forces
Solution
.NET RIA Services framework supports end-to-end use of data from DAL (data access layer) of your choice to presentation tier. The data can be shaped for presentation tier. This framework was built on ASP.NET to define and support a pattern for exposing a set of operations on your domain object to presentation tier particularly Silverlight. A domain object contains set of CRUD and custom business operations with domain entities. In this framework, the domain object is called as “DomainService”. Once you define a DomainService at business tier based on the data from database using ADO.NET Entity Framework or LINQ2SQL, this framework generates code corresponding client tier code that can be used for data binding, validation, authentication, etc.
The following image which was taken from .NET RIA Services guide gives you to understand how this framework is designed to scale across different presentation technologies and DAL components.

References




For those whomsoever Silverlight x.x may concern, this is the news for you. Microsoft has released Silverlight 3.0 today at MIX09 with numerous new features and improvements.
In addition to 60+ new UI controls and new features, I am really excited with the following features:
Important Note
Once you installed Silverlight 3.0 Beta tools for Visual Studio 2008, Silverlight 3.0 is the only choice for you. You cannot use Silverlight 2.0 SDK.
New Features
Improvements
Download the SDK and VS 2008 SP1 tools at http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=11dc7151-dbd6-4e39-878f-5081863cbb5d.
Start learning this beta SDK at http://silverlight.net/getstarted/silverlight3/default.aspx
Happy Coding!.




What is NGen?
A tool comes with .NET framework, which is used to generate native image of a managed assembly.
The managed assemblies (.dll and .exe) contain IL code that are not understandable by native operation system. When executing the managed application, JIT compiler compiles the IL code into native code. This would require some amount of memory for JIT compiler and the application takes some time on start-up.
NGen provides pre-compilation option so that you can compile your application IL code into native code one shot before starting the application itself. The .NET framework libraries, Paint.NET are some applications use NGen.
How it works?
NGen invokes “Compilation Worker” when you give a managed assembly for native code generation. Compilation Worker loads runtime and uses JIT compiler to create native code. It places the JIT generated native code into the assembly cache in a file with name ”YourAssemblyName.ni.dll”. This file is generally called as “native image”. The cache folder path is %Windows%\Assembly\NativeImages_v2.0.50727_32. When you run the application, CLR finds the native image of an assembly and executes it, if the assembly exists on cache; otherwise it does normal path.
Advantages
Is It Value-Add?
The advantages make us very happy after all we are the guys working behind virtual machines a.k.a CLR. However, you cannot write a single rule of thumb for NGen usage. Using NGen is varied based on the situation or requirement. One rule of thumb for NGen would be:
Do not use native images for server side applications. The assemblies for a server side applications are loaded and JITted only once at the first time of request. For succeeding requests, the JIT compiled codes are executed. So, there is no benefit using NGen on server side application.
Consider the following for client side applications before decide to use NGen:
So, “Think twice before NGen” for client side applications.




In 2004, I had bought “Software Factory” book written by Microsoft techies and it was more conceptual and theoretical. This book approaches the model driven development (MDD) in a different perspective, and introduces software factory and domain specific language (DSL) concepts. The theory was successfully implemented in VSTS. Unfortunately, it was not mature and very inconsistent. The software factory and DSL tools were only used by Microsoft itself. They did not touch the heart of ISVs. Event though, I have used Microsoft’s Webclient Software Factory (WCSF) and WCF Service Model Factory successfully and bit consistently in one of our product development. I had really seen the benefit of MDD approach from DSL perspective upfront. However, I am expecting the mature and stable version of this.
Thanks God, Microsoft concentrates more on this and came up with “Oslo”. The hot core part of Oslo is Oslo Modeling Language “M”. The definition for M in MSDN:
M lets users write down how they want to structure and query their data using a convenient textual syntax that is convenient to both author and read.
With Oslo, Microsoft boosts the software factory concept. You can design and develop your application with UML 2.0 standard using M. M is a textual and declarative language which enables you to write down what you want from your data without worrying about underlying technology and platform. M will compile both on Win and Linux.
In parallel, Microsoft is developing Quadrant, a model designer for M which allows you to design graphically.
You can save your models in SQL Server.
Hope, we can see a smart changes in our SDLC by Oslo.




Interstingly, when I typed the term “microformats”, my hand confused and typed “Microsoft”.
However, it took some period to adopt this standard by major web vendors Microsoft and Mozilla.
What is Microformats?
This is one way of enabling web as semantic. The current web markups are very keen on displaying content on the browsers. As an user we know what is on the page, as a system it just displays it. However, how can develop a system to organize, collect and manage the contents from web pages? Previously, it is impossible. There are millions of terra bytes of content exist in the web. But now, Semantic Web which was initiated by Tim Berner Lee helps us to make this possible.
Microformats are one such standard which reuse existing markup elements to convey semantic of the data. For example, the following snippet shows a hCard telephone contact details.
<span class=”tel”>
<span class=”type”>home</span>:
<span class=”value”>+91.044.111090190</span>
</span>
Oomph
Microsoft Oomph is a toolkit to for web developers, designers and users, making it easier to create, consume, and style Microformats. It comes up with:
Visit: http://oomph.codeplex.com/ to know more and download the toolkit.




At Microsoft Lab, they have developed a language called Spec# for extending C# long back. The extensions covered now are:
The main outcome of this is Code Contracts .NET. For more details, http://research.microsoft.com/en-us/projects/specsharp/.




Hello All,
I am very happy to announce the launch of my very own blog udooz.net/blog for my technology blogging.
Thank God.
Cheers,
M Sheik Uduman Ali


More Options ...
Categories
Tag Cloud
Blog RSS
Comments RSS

Void « Default
Life
Earth
Wind
Water
Fire
Light 