First I must start by saying that IBM/Lenovo laptops are very stable, durable and high performance machines. Few months ago, I got an X61 Thinkpad. I was readily impressed by its sleel looks and compact size (I'm big fan of lightweight and small machines). Small didn't mean less power. It has 4GB RAM and dual core 64bit processor. I would like to share some of my expriences with it.

OK now the good part of this post. There's no touch pad on it :) and what you have is a small red mouse button in the middle of the keyboard. My initial thoughts about it were sarcastic. And while using it for first few days, I kept rubbing my thumb on the area below mouse-left and mouse-right buttons. But hey, there's nothing there to scroll or move mouse. Now I had to use my index finger to caress the red mouse button and click the mouseleft button for left clicks with my thumb. I came from using Sony VAIO where I would simply "tap" my finger to do a click. However, the good thing is that mouse-left button (or mouse-right) for that purpose doesn't really make much noise (unlike my Sony VAIO SZ series). My first experiences with this obscure mouse button were not too good.

Now the second problem with this middle-mouse. In "normal" laptops I could scroll page(s) by sliding my finger in the right or bottom corners of the touch pad for vertical and horizontal scrolling respectively. But since there's no touch pad on it, there is a button in the middle of mouse-left and mouse-right buttons, which can be pressed (kept down) and red middle-mouse button moved to scroll in either direction. It works very similer to pressing scroll wheel of a traditional mouse and then moving the mouse. But not impressive because if I don't have a proper driver for it, it would move (scroll) the page in mutliple directions. So there exists a driver that lets me scroll in either horizontal or vertical directions instead of having a free hand movement.

OK now let's talk about the cognitive learning part in using such devices. Sometimes this learning could actually be better for ergonomics of the human computer interaction. After couple of months of playing with the middle-mouse button, I realized that I'm having to move my hand much less, and my fingers (for the purpose of mouse movements) don't have to move much. Which made me realize that my hands aren't getting as tired as they were with a touch-pad based laptop. Not to mention, there was some extra time involved in placing my fingers (thumb and index) to the right place before I could go start moving my mouse and clicking etc. It's a bit different than just moving index finger on any part of the touch-pad. It's worthwhile to notice that IBM/Lenovo probably didn't put a touchpad in this computer due to its size (12 inch screen) but the bigger Lenovo models contain both a touchpad and the middle-mouse.

Actually because I did talk about Sony, I should also mention about an ultra mobile PC I used couple of years ago (I'll write in detail about it, later). The similarity between the Lenovo X61 and Sony UX Series is that UX also had a similar mouse button in the top right corner of the base of the device. BTW it's a touch screen tiny computer with only 4.5 inch screen and it runs Vista.

Conclusion: I think middlemouse button is bit odd to start with but it certainly provides better ergonomics when used for a longer bit of time.

 “Do you like dynamic challenges in web application development? A large scale internet applications on the world’s top commercial web site sounds interesting to you? Do you want to work on cutting edge web application using state of the art Web 2.0 technologies? If you answer yes to any of the above questions, here is the opportunity for you.

Marketing Center Of Excellence (Global Marketing Platform) division’s World Wide Events & Profile Center team is looking for a self motivated and seasoned senior web UI developer. This is an application that allows partners to create live, in-person and live meeting events via the partners’ extranet application, and these events are exposed on external internet facing site https://msevents.microsoft.com to the users who might be interested in registering and attending the events. Team is working on renovating the Web UI and Middle Tier. In addition to the current features, next generation system includes streaming videos and rich UX via Silverlight, integration with adCenter, contextual display of events on third party sites, communities integration, pluggable controls for other Microsoft.com properties etc. This is a great opportunity to impact the external customers with first hand code. Some of the highlights of the project includes Web UI instrumentation for analyzing user’s cognitive behavior and collecting usage, performance and error data directly from the client side XMLHTTP calls, Web UI and Middle Tier based on modern design patterns, WCF (Indigo) and Web Services based contracts between Middle Tier and the adopters, individually testable and scalable layered architecture.

The required skills for this opening are: proficiency in OOP and C# (2.0), ASP.NET (Controls, Life cycle, Integration, Performance and Payload optimizations), DHTML, XML/XSL, JavaScript (Object Oriented), Web Services, WSE, AJAX (strong custom and Atlas/’ASP.NET AJAX’ implementations).

Knowledge of KAF/ECHO Automation, XAML/Silverlight, SQL Server 2005 (TSQL, Profiler) is desirable. A BA/BS degree in Computer Science, Electronics or Mathematics, 8+ years or an MS in similar fields with 7+ years of professional experience is required.

 If it interests you and you have desired qualification, please contact me.

-     Use generic collections instead of Hashtables and ArrayList types

-     If using Generic types, then refrain from using foreach loop on the collection. Rather use ForEach method to loop through via an anonymous method predicate (much faster because doesn’t create the Iterator). For non generic types try to use for loop instead of foreach if the data being traversed is huge

List<string> list = new List<string>();

list.Add("aa");

list.Add("bb");

//option 1:

foreach(string str in list)

   Console.WriteLine(str);

//option 2: RECOMMENDED

list.ForEach(delegate(string str) {

 Console.WriteLine(str);

});

-    Nullify unused objects (doesn’t collect, but marks for collection and ceases from getting promoted into next generation)

-    IF conditions having just one item in if and else, should be used as ternary operator (? Sign)

e.g. instead of the code:

int i;

if(someConditionTrue)

        i = 3;

else

        i = 4;

It is better to write the above 5 lines into just one:

int i = someConditionTrue ? 3 : 4;

-     Use ‘as’ operator instead of direct typecast using parenthesis with the exception of overloaded explicit cast operator, it saves from NullReferenceException and InvalidCastException

-     Refrain from XmlDocument usage for navigational purpose, please either use XmlTextReader for sequential access or XPathDocument for XPath based data retrieval               

-     For server side XSL transformation, Use XslCompiledTransform instead of XslTransform (Please check https://blogs.msdn.com/antosha/archive/2006/07/24/677560.aspx ). For client side transformation, try to load Xsl file asynchronously whenever possible via XMLDOM or XsltProcessor (Geckos)

-     Always join your threads in a web page, if used (otherwise the page will be rendered and workers will continue operating at the server cost, and ofcourse the results will be unpredictable)

Let's say you opened two threads in a web page using the following:

Thread AThread  = new Thread(new ThreadStart(CallProcOne));

AThread.Start();

Thread CThread  = new Thread(new ThreadStart(CallProcTwo));

CThread.Start();

//Now it is recommended to do this:

AThread.Join();

CThread.Join();

-    Always do NULL checking before operating on an object, NullReferenceException is widely occurring exception in most applications and only a preventive programming can help us get the real error

-     Handle most specific (expected) exceptions in the catch blocks before deciding towards general Exception, and please don’t use catch without an exception object if you’re not really writing P/Invoke in C#

1. If you're conservative to keep your page size to low, you may not use ViewState.
2. The controls were built using client side script and/or their data was populated dynamically (such as AJAX or XML DSO etc), these bindings will need to happen once again when page is rendered back after the error or the status check

Is it really needed to Postback when saving data using webforms? Answer is No. Because we can utilize an auxilliary "form saver" page/handler that will be posted data from the client using XMLHTTP asynchronously, and whenever it finishes processing, it can return back the XML as a response metadata. This XML response will tell whether the operation to save form data succeeded or not. Also we can customize it to return some status codes (may be used to redirect after saving data etc) and meta language to perform post-save processing on the client side using JavaScript.

1. How to speed up the process of data fetch/load at the server to rendering it to the web client.
2. Reduce the markup

I discussed point 2 in my previous post (another way to reduce markup is to not "Generate" X/HTML on the server, do it using XSLT on client). Anyhow 2. is also indirectly correlated to 1.

As a proposed solution, what we need here is the true asynchronous loading of the web page that is feature/content rich. So how do we achieve that!? Ironically the answer lies in both the developer's mind (what data to async) and the methodology I'm about to discuss. Here is my thought process for manually dividing the payload distribution

1. Logically separate the different data units of the web page (viz. in a news site, breaking news, stock ticker and weather information can be considered isolated if they all come from different data sources or in other words they have be explicitly loaded by using a DB call)
2. Render the page from server with placeholder markup for these logical data units (i.e. no data, no DB calls have been made so far) and a small JavaScript block containing boolean variables values set to true for which [data units] content needs to be loaded later.
3. After the server request has returned lightweight payload (missing data) and quicker response (server didn't have to do much processing cause most importantly DB calls were skipped), go through the JavaScript boolean variables set by the server, each of them signifies a data units. which ever is set to true, make AJAX call to grab data from the server and populate in the respective placeholders of data units.
4. Next is upto the developer to either render X/HTML out of the data retrieved using plain JavaScript or XSLT. Tip: If using XSL, remember they can also be loaded asynchronously! So higher performance can be achieved if the XSL is large and heavy markup is rendered out of it.
5. In the end, page will appear as being loaded asynchronously and much faster than it would have using a single server send. It's like using multiple small funnels instead of a big one, that is sequential.

1. Processing these records on the web server (saving CPU)
2. Rendering markup from server on the HTTP wire (which can be processed and rendered by a cheaper mechanism on the client browser such as XSLT/JS)

And costs us this

1. More server requests (lightweight though)

However to partially get around the cost mentioned above, we need to keep once loaded data into browser memory variables and not make the request if same thing is being requested again.

Coming back to the main issue, to determine how much data should be rendered by the server, and how much responsibility can be given to the client to load (XML) and process without causing IE memory leaks/overruns. Next is to devise an algorithm to determine this division factor on the basis of size of total renderable data.

let d=data; t=time

d(c) + d(s) = d(tl)      ... (1)

t(c) + t(s) = t(tl)         ... (2)

However, in (2) t(s) is a variable and t(c) is constant [assuming all clients have as usual near about high amount of memory and CPU available]. In order to find the value of d, use of induction could be handy, if performance can be optimized or at least standardized as acceptable. I'll post what I find out of this experiment.