Ideally, thats when a developer should say goodbye to the application vowing never to see the code again. Coz, if  he does, he’d end up mighty disappointed. Future developers would have literally pillaged the application to  systematically eliminate any traces of the original design, the code would be littered with dirty bug fixes and so -called enhancements that don’t “enhance” anything. The customer doesn’t care because the application still works,  the managers don’t care because they meet their revenue targets and the timelines, and the developers never cared  in the first place.

Keeping that in mind, I listed down a few ways which might help save your application from meeting the same fate.

• Keep it Simple:  The oft repeated rule in software design is “Keep everything as simple as possible, but not  simpler”. If the design is too complex, then in all probability no developer would take the pains to go through it  and understand the whole thing. Many software engineers are guilty of trying to force fit their code to use a certain design pattern. Instead,look for the pattern which best fits your requirement

• Keep it Modular: Dividing your application into logically seperated projects makes it easier to identify the right  places to make the changes. Proper namespaces help too. For e.g. an assembly with the namespace  ABCApplication.HelperObjects.FileIOOperations leaves no space for doubt about what it does.

• Keep it Visual: Sure, you might find the 1000 page SMTD an interesting read, but not everyone else will. Remember a  bored developer would be the most likely to introduce a dirty fix in the code. So, to keep things interesting, go  for easy to understand graphics and images. MS Visio is a great tool to model your application, and it supports  automatic code generation as well (Enterprise Architect version). And after creating the model, dont leave it in a  random location that even you would forget in 2 weeks. My advice is to check it in the Source control along with  the code and add it to the Visual Studio Solution.

• Keep it Commented: Good commenting is the most potent weapon in your arsenal to guide/warn/ prohibit future  developers from making changes they shouldnt be doing. XML comments are a great way to maintain uniform commenting  standards across the application and can also be used to generate comment documentation automatically (using the  /doc switch while compiling) . A good way to convey how you intended the code to be used is to include a sample code block in the xml comments itself. Keep it mind though, that the comments are stripped out by the compiler, so  if you want comments to appear in the intellisense while using the assemblies, then the generated documentation  file must be packaged along with the assembly.

First, we need to set up Visual studio  to use the Sons of Strike. A few simple steps mentioned below are needed to accomplish this:-

• Enable Unmanaged Debugging in the Project Properties

• Set the symbol server to  *C:\localcache*http://msdl.microsoft.com/download/symbols. The symbol server can be set by going to Tools -> Options-> Debugging. This step allows Visual studio to download the symbols needed for debugging from the Microsoft server.

• Set a breakpoint in the code and press F5 to start the program in debug mode. Once the application hits the breakpoint, load the SOS.dll using the command .load SOS in the Immediate Window.

Now we are ready to use the debugging extension. And SOS is also compatible with debugging tools like WinDbg in case you are comfortable with using that. Click here for a list of SOS commands.

Now, lets see the code that we would use for seeing how generics work. It consists of a Generic Type Customer which contains a list of the generic type and a public integer property.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Employee
    {
 
        public int EmployeeID;
        public static int age;
        public static string Name;
    }
 
    class Customer<T>
    {
        public int CustomerID;
        List<T> _innerList = new List<T>();
 
        public List<T> ListItems { get { return _innerList; } }
 
        public void AddItems(T _addObject)
        {
            _innerList.Add(_addObject);
        }
    }

The main method to call this code is below. We create the Customer class in three types – a string, an integer and a custom Employee type. Of these the string and Employee are reference types while integer is a primitive value type.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

static void Main(string[] args)
        {
            Customer<string> _cxStringObj = new Customer<string>();
            Customer<int> _cxIntObj = new Customer<int>();
            Customer<Employee> _cxEmpObj = new Customer<Employee>();
 
            _cxStringObj.CustomerID = 34;
            _cxStringObj.AddItems("Ganesh");
 
            _cxIntObj.CustomerID = 23;
            _cxIntObj.AddItems(43);
 
            _cxEmpObj.CustomerID = 34;
            _cxEmpObj.AddItems(new Employee());
        }

Every .NET class has two main data structures it uses to maintain type identity – the MethodTable and EEClass. Every object has a pointer to its MethodTable, and this methodtable contains a pointer to the EEClass. In .NET 1.1, the EE class was the strongest identifier of Type Identity of an object, however with .NET 2.0 and the implementation of Generics, Generic Types can share the same EEClass, and the MethodTable takes on the mantle of being the unique type identifier.

There are two main ways of implementing Generics which were proposed by the researchers who were working at Microsoft (This paper provides details of the implementation).

• Expansion: In this way, whenever the runtime encounters a generic type, the code could be generated on the fly for the type being called. For e.g. in our code, when the object Customer<string> was encountered, it could have expanded into the string representation of the object. When the type Customer<int> was encountered, a similar expansion can be done for it.

• Code sharing: In this approach only a single instantiation is done for the generic type, and it is reused for all the calls.

The method chosen in the end was a mixture of both these approaches. Generic types share as much code as possible They contain the same EEClass as mentioned before, but also have distinct MethodTables. Even though they have distinct MethodTables, code is shared between compatible types (all reference types).

Fire up the debugger and load the SOS.dll. To see the particular instances of the type on the heap give the Command DumpHeap -type . Once all the three objects have been created, lets see the result of this command.

!DumpHeap -type Customer
 Address       MT     Size
01ed35cc 002331d8       16
01ed3604 00233284       16
01ed3638 0023336c       16
total 3 objects
Statistics:
      MT    Count    TotalSize Class Name
0023336c        1           16 GenericsTry.Customer`1[[GenericsTry.Employee, GenericsTry]]
00233284        1           16 GenericsTry.Customer`1[[System.Int32, mscorlib]]
002331d8        1           16 GenericsTry.Customer`1[[System.String, mscorlib]]
Total 3 objects

As you can see from the MT column, all the three objects have different MethodTables. Lets see the MethodTables for each of the three type instantiations.

The command is DumpMT -MD . First the Employee type. Think of the MethodTable as an extension to a conventional vtable which simply contains the method pointers. The MethodTable’s vtable points to 7 slots, 4 of which are inherited from the parent Object class and three which are defined by the object itself. If you see the JIT status, there is a YES and NONE. The NONE means the method has never been called by the JIT Compiler and it points to a temporary stub. The first time the method is called, it is compiled on the fly and the temporary stub is replaced with the actual method pointer. To optimize performance, JIT defers execution and compilation till as late as possible.

!DumpMT -MD 0023336c
EEClass: 00231420
Module: 00232c5c
Name: GenericsTry.Customer`1[[GenericsTry.Employee, GenericsTry]]
mdToken: 02000004  (Projects\GenericsTry\GenericsTry\bin\Debug\GenericsTry.exe)
BaseSize: 0x10
ComponentSize: 0x0
Number of IFaces in IFaceMap: 0
Slots in VTable: 7
--------------------------------------
MethodDesc Table
   Entry MethodDesc      JIT Name
70766aa0   705e4a34   PreJIT System.Object.ToString()
70766ac0   705e4a3c   PreJIT System.Object.Equals(System.Object)
70766b30   705e4a6c   PreJIT System.Object.GetHashCode()
707d7550   705e4a90   PreJIT System.Object.Finalize()
0023c058   0023313c     NONE GenericsTry.Customer`1[[System.__Canon, mscorlib]].get_ListItems()
0023c060   00233148     NONE GenericsTry.Customer`1[[System.__Canon, mscorlib]].AddItems(System.__Canon)
0023c068   00233154      JIT GenericsTry.Customer`1[[System.__Canon, mscorlib]]..ctor()

Lets see the MethodTable for the integer type. As you can see the EEClass for the Integer and Employee types are not same, this is because they are not compatible types and hence no code sharing can take place

!DumpMT -MD 00233284
EEClass: 002314b4
Module: 00232c5c
Name: GenericsTry.Customer`1[[System.Int32, mscorlib]]
mdToken: 02000004  (\GenericsTry\GenericsTry\bin\Debug\GenericsTry.exe)
BaseSize: 0x10
ComponentSize: 0x0
Number of IFaces in IFaceMap: 0
Slots in VTable: 7
--------------------------------------
MethodDesc Table
   Entry MethodDesc      JIT Name
70766aa0   705e4a34   PreJIT System.Object.ToString()
70766ac0   705e4a3c   PreJIT System.Object.Equals(System.Object)
70766b30   705e4a6c   PreJIT System.Object.GetHashCode()
707d7550   705e4a90   PreJIT System.Object.Finalize()
0023c080   00233254     NONE GenericsTry.Customer`1[[System.Int32, mscorlib]].get_ListItems()
0023c088   00233260     NONE GenericsTry.Customer`1[[System.Int32, mscorlib]].AddItems(Int32)
0023c090   0023326c      JIT GenericsTry.Customer`1[[System.Int32, mscorlib]]..ctor()

The last one is the string type. This brings us to interesting conclusions. Compare the first MethodTable with the last one. Both are reference types and hence compatible with other. It can be observed that the string and Employee tables have the same EEClass 00231420. The integer type however has the EEClass 002314b4. There is no way for primitive value types to share code with each other since they differ in size. For e.g. If we created a bool type for Customer class, it would still have a different EEClass and MethodTables.

!DumpMT -MD 002331d8
EEClass: 00231420
Module: 00232c5c
Name: GenericsTry.Customer`1[[System.String, mscorlib]]
mdToken: 02000004  (\GenericsTry\GenericsTry\bin\Debug\GenericsTry.exe)
BaseSize: 0x10
ComponentSize: 0x0
Number of IFaces in IFaceMap: 0
Slots in VTable: 7
--------------------------------------
MethodDesc Table
   Entry MethodDesc      JIT Name
70766aa0   705e4a34   PreJIT System.Object.ToString()
70766ac0   705e4a3c   PreJIT System.Object.Equals(System.Object)
70766b30   705e4a6c   PreJIT System.Object.GetHashCode()
707d7550   705e4a90   PreJIT System.Object.Finalize()
0023c058   0023313c     NONE GenericsTry.Customer`1[[System.__Canon, mscorlib]].get_ListItems()
0023c060   00233148     NONE GenericsTry.Customer`1[[System.__Canon, mscorlib]].AddItems(System.__Canon)
0023c068   00233154      JIT GenericsTry.Customer`1[[System.__Canon, mscorlib]]..ctor()

One more thing of notice is the Method Descriptors for the first and third types. The AddItems method in Customer class has the same Method descriptor for both the string and Employee implementation. So even after a MethodTable is duplicated, both those entries still point to the same Method Description. Even the name has the type System.__Canon, which is dynamically replaced by the type on which the method is called. This is an illustration of the second approach of code sharing given by the researchers from Microsoft.

Once the code for AddItems method is called for the first time, it is JIT Compiled and assigned a code address. The Method Descriptor holds this code address which is assembly code and can be viewed by the SOS command !u.  Till the method is Jitted, there is junk value in this field on the MethodDescriptor.

!DumpMD 00233148
Method Name: GenericsTry.Customer`1[[System.__Canon, mscorlib]].AddItems(System.__Canon)
Class: 00231420
MethodTable: 0023316c
mdToken: 06000005
Module: 00232c5c
IsJitted: yes
CodeAddr: 00aa0298

Running the CodeAddress would give you a bunch of assembly code that is executed when the method is called.

!u 00aa0298
Normal JIT generated code
GenericsTry.Customer`1[[System.__Canon, mscorlib]].AddItems(System.__Canon)
Begin 00aa0298, size 42
>>> 00AA0298 55               push        ebp
00AA0299 8BEC             mov         ebp,esp
00AA029B 57               push        edi
00AA029C 56               push        esi
00AA029D 53               push        ebx
00AA029E 83EC34           sub         esp,34h
00AA02A1 33C0             xor         eax,eax
00AA02A3 8945F0           mov         dword ptr [ebp-10h],eax
00AA02A6 33C0             xor         eax,eax
00AA02A8 8945E4           mov         dword ptr [ebp-1Ch],eax
00AA02AB 894DC4           mov         dword ptr [ebp-3Ch],ecx
00AA02AE 8955C0           mov         dword ptr [ebp-40h],edx
00AA02B1 833D142E230000   cmp         dword ptr ds:[00232E14h],0
00AA02B8 7405             je          00AA02BF
00AA02BA E8BABC3571       call        71DFBF79 (JitHelp: CORINFO_HELP_DBG_IS_JUST_MY_CODE)
00AA02BF 90               nop
00AA02C0 8B45C4           mov         eax,dword ptr [ebp-3Ch]
00AA02C3 8B4804           mov         ecx,dword ptr [eax+4]
00AA02C6 8B55C0           mov         edx,dword ptr [ebp-40h]
00AA02C9 3909             cmp         dword ptr [ecx],ecx
00AA02CB E8E0F1D16F       call        707BF4B0 (System.Collections.Generic.List`1[[System.__Canon, mscorlib]].Add(System.__Canon), mdToken: 060019f1)
00AA02D0 90               nop
00AA02D1 90               nop
00AA02D2 8D65F4           lea         esp,[ebp-0Ch]
00AA02D5 5B               pop         ebx
00AA02D6 5E               pop         esi
00AA02D7 5F               pop         edi
00AA02D8 5D               pop         ebp
00AA02D9 C3               ret

In this post, we have looked at how the CLR treats Generics and how it takes care of performance implications of Generics code by sharing as much code as possible without having to needlessly box and unbox the types being passed to the Generic classes.

So I decided to poke around the API and write a simple extension. Though it doesnt compare to FireFox yet with much of the browser still not accessible, but I am sure future versions will bring much better customization capability. The extension I wrote is very simple and just displays the latest trending topics from twitter. The source can be downloaded here and the packaged version here.

Lets see the anatomy of a Chrome Extension. An Extension consists of three main parts

• Manifest
• UI
• All your other files like scripts, stylesheets, images, etc

The manifest is a json file which contains the metadata about your extension. Details like Title, Author etc

{
  "name": "Twitter Trends",
  "version": "1.0",
  "description": "Displays Current Trending Topics",
  "icons": { "128": "icon.png" },
  "browser_action": {
    "default_title": "Twitter Trends",
    "default_icon": "icon.png",
    "popup": "Background.html"
  },
  "permissions": [
    "tabs",
    "http://twitter.trends.free.fr/*"
  ]
}

As you can see, it contains basic details like name, version, icon etc. The popup attribute tells us the page to open when the browser button is clicked. As you can see I have specified a normal HTML page here. A popup extension is nothing but a simple HTML page opened when the toolbar button is clicked. Another interesting part is the permissions section. Here we can specify what all websites the extension can make AJAX calls to retrieve data. Since it matches based on wildcards, a * denotes all possible subdirectories under the website.

Now the HTML part. Since its a normal HTML page, you can include references to scripts, images, style sheets etc. The extension directory works as the root and all paths must be relative to it. Since its a simple page, I included all the scripts and styling information in a single page.

First the styling information. Always helps to keep this separate.

  body {
  font-family: helvetica, arial, sans-serif;
  font-size: 12px;
  overflow: hidden;
  background-color:#ddeef6;
  }
 
  #title
  {
      font-size:14px;
      overflow:hidden;
  }
 
  #mainDiv
  {
      min-width:175px;
      margin-top:5px;
  }
 
  .topicDisplayClass
  {
      display:block;
     min-height:2.2em;
     cursor:pointer;
  }
 
  .linkClass
  {
      color:#2276bb;
      text-decoration:none;
      vertical-align:middle;
      padding-left:2px;
  }
 
  .topicDisplayClass:Hover
  {
      background-color:#edfeff;
  }

Next the javascript. This is the most important part of the extension. What we do here is retrieve the RSS feed for the trending topics and parse it as an xmlDocument. After iterating thorough this xml, a span element is dynamically created for each item and it is appended into our main content holder. This main function call is delayed using the setTimeout function. We do this in order to let the user see the popup and see some progress which data is being fetched. Writing this in the onload event would make the user wait for the whole process to complete before seeing the popup.

/* Developer  : Ganesh Ranganathan
* Date       : 02/12/2010
* Description: This is a Google Chrome Extension created to display
            latest trending topics on twitter. */
 
//Global variables: the xmlHttpRequest and Feed URL
var _req;
var _feedURL = 'http://twitter.trends.free.fr/feed/';
 
function main() {
    //Call the loading method after a slight delay to allow
    //Chrome to load the extension body. Else it looks ugly with
    //the pressed button waiting for the feed to load.
    setTimeout("delayedCall()", 20);
 
}
 
function delayedCall() {
    //No browser compatibility code Yay!!!
    _req = new XMLHttpRequest();
    //Hooking up the readystate changed event handler.
    _req.onreadystatechange = function() {
        if (_req.readyState == 4 && _req.status == 200) {
            //Come here only if all data is loaded.
            var doc = _req.responseText;
            var parser = new DOMParser();
            //Parsing the Data into the XML dom for manipulation
            var xmlDoc = parser.parseFromString(doc, "text/xml");
            var mainDiv = document.getElementById('mainDiv');
            mainDiv.innerHTML = "";
            //Getting all the items
            var items = xmlDoc.getElementsByTagName('item');
 
            for (var i = 0; i < items.length; i++) {
                //Iterating through all the items and getting the title
                //and link. The description isnt a big deal in this feed.
                var title = items[i].getElementsByTagName('title');
                var link = items[i].getElementsByTagName('link');
                //Create an anchor and a span
                var spanNode = document.createElement('span');
                var linkNode = document.createElement('a');
                //Set Link to span
                linkNode.setAttribute('href', link);
                linkNode.innerText = title[0].childNodes[0].nodeValue;
                linkNode.className = 'linkClass';
                spanNode.appendChild(linkNode);
                spanNode.className = 'topicDisplayClass';
                var str = link[0].childNodes[0].nodeValue
                //Hooking the click event handler to the span
                //It calls the chrome tabs API to open the clikced
                //URL in a new tab
                spanNode.addEventListener("click",new Function("clickHandler('"+str+"')"),false);
                mainDiv.appendChild(spanNode);
            }
        }
    }
 
    //Without these two the AJAX request would never get sent.
    _req.open("GET", _feedURL, true);
    _req.send(null);
}
function clickHandler(str) {
    chrome.tabs.create({ url: str });
}

The markup is largely simple. Just the main content holder which contains a progress bar which is displayed to user while we load the data. Once that is done, the progress bar is replaced with the span nodes containing the trending topics.

<span id="title">Trending Topics</span>
<div id="mainDiv">
<!-- A Progress Bar to show the user something is being done -->
<img src="ajax-loader.gif" alt="" width="175px" /></div>

Now the manifest, html and image files need to be in a single folder. After that go to Chrome and click the customize dropdown button, and select Extensions. In the extensions page, select Load Unpacked Extension and select the folder where the extension files reside.

Once the extension is loaded, it shows as unpacked and you can do all the testing here by reloading it everytime any changes are done.

After testing, we can choose the pack option to package the extension for download. A .crx file would be generated which can be distributed for download. Below are some screenshots of the extension we just created.

Data is loading

Automated testing is an integral part of Test Driven Development. A developer simply doesn’t have the time to do functional unit testing of his application, an effort which would neither be reproducible, nor comprehensive. Hence developers use Automated testing tools which decrease the testing effort, even if a little bit more code needs to be written.

The biggest problem while automating testing for applications, especially web applications is the tight coupling between layers making it impossible to test one layer without the another. This can create a lot of complications, since you might get false positives and negatives. Imagine a scenario where you write a test case for a business layer method which retrieves some data from the database and processes it. The aim here is to only test the business layer’s functionality, but if there is a concrete dependency on the data layer, then the result of the test would inevitably depend on the retrieval of data. This is where you could get false positives or negatives.

Hence the reasoning that the test cases should be limited to only the functionality being tested. Consider the below code.

    //Your Business Class
    class BusinessObjects
    {
        //This is a concrete dependency on the dataLayer Object
        private DataObjects _dataLayerObj;
 
        public BusinessObjects()
        {
            //Initializing the DataLayer object
            _dataLayerObj = new DataObjects();
        }
 
        //Get the customer's Name in upper case
        public string GetCustomerNameInUpperCase(int _customerID)
        {
            return (string)_dataLayerObj.RunScalarQuery("Your Select Query here").ToUpper();
        }
    }

So If you write a test on the GetCustomerNameInUpperCase method, it would need to have the database up and running in order to pass. To avoid this, a technique called dependency injection is used in which the application’s layers are loosely coupled with each other enabling us to test each layer’s functionality independent of each other.

This is accomplished by introducing an interface from which the Data layer would inherit and do its work. The business layer would be aware only of these interfaces. Business layer would no longer care about the implementation and thus would allow us to define our own implementation of the interface. This implementation can be “injected” through an additional constructor. Lets see the code for the data layer now.

    //This is the Interface on which the business layer
    //would depend and not the data layer class itself
    interface IData
    {
        public object RunScalarQuery(string _selectQuery);
    }
 
    //Other code is oblivious to the implementation behind
    //the data layer as long as it returns the name
    class DataObjects: IData
    {
        //Implementation of the interface
        public object RunScalarQuery(string _selectQuery)
        {
            //Do all the database related stuff
            return "Some Customer's Name";
        }
    }

Now we would need to modify the business layer to make it depend on the interface.

   class BusinessObjects
    {
        //It now depends on the interface
        private IData _dataLayerObj;
 
        public BusinessObjects()
        {
            //Initializing the DataLayer object
            _dataLayerObj = new DataObjects();
        }
 
        //This is the additional constructor that is used
        //to inject a custom implementation
        public BusinessObjects(IData _dataObject)
        {
            this._dataLayerObj = _dataObject;
        }
 
        //Get the customer's Name in upper case
        public string GetCustomerNameInUpperCase(int _customerID)
        {
            return ((string)_dataLayerObj.RunScalarQuery("Your Select Query here")).ToUpper();
        }
    }

Now lets write the test case for this method. Instead of using the default constructor making the Business layer go to the database for the customer’s name, our very own Mock Class does the trick by supplying a dummy value.

    [TestFixture]
    public class BusinessLayerTests
    {
        BusinessObjects _bObjects;
 
        [SetUp]
        public void Init()
        {
            //Pass our own implementation of IDATA using
            //the additional constructor we defined
            _bObjects = new BusinessObjects(new MockClass());
        }
 
        [Test]
        public void CheckIfUserNameIsUpper()
        {
            //User regular Expressions to make sure all upper cases are returned
            string _returnedName = _bObjects.GetCustomerNameInUpperCase(2342);
            Console.WriteLine(_returnedName);
            Assert.IsTrue(Regex.IsMatch(_returnedName, "^[A-Z]+$"));
        }
    }
 
    //This inherirs from IData
    public class MockClass : IData
    {
        #region IData Members
 
        public object RunScalarQuery(string _selectQuery)
        {
            //Simply return a lower case name
            return "lowercaseName";
        }
 
        #endregion
    }
 
}

This does seem like too much work to test such a simple functionality, but believe me, the benefits grow exponentially with the size of the project. As you start following this approach, it would be easier to test as you go, making the chances of missing out on that tiny bug much lesser. And at the end of the day, nothing makes the developer more happy than seeing all his unit tests pass with the large green NUnit bar.

After months of begging for a google wave invite, I had given up on the possiblilty of ever getting inot GWave at the preview stage. But yesterday my orkut status message got me two invites from friends.

Ever since I got it, am trying to find someone to start a wave with, but as luck would have it, everyone seems to be busy. Tried to be a part of a public wave but didnt get the hang of it yet.

There may be minor glitches on the way, but the idea of redefining something that has existed before Internet did, is truly revolutionary. Good luck to google on this one!!!