WebSites Runtime Performance Resources

I attended Build 2013 in SFO and on this excellent talk by Tobin Titus on Web Runtime Performance Tobin shared lots of insight on Web Runtime performance. He shared the list of resources which I thought is beneficial who is looking for improving website performance.

Books on Websites Performance

High Performance Websites
Steve Souders, September 2007

Event Faster Websites: Best Practices

Steve Souders, June 2009

JavaScript Patterns

High Performance JavaScript Nicholas Zakas, March 2010

JavaScript the Good Parts Douglas Crockford, May 2008

JavaScript Patterns Stoyan Stefanov, September 2010

JavaScript Cookbook Shelley Powers, July 2010

Microsoft Guidance

Windows Store App: JavaScript Best Practices
MSDN, December 2012

Performance Tricks to Make Apps & Sites Faster
Jatinder Mann, Build 2012

50 Performance Tricks for Windows Store Apps

Jason Weber, Build 2011

Engineering Excellence Performance Guidance

Jason Weber, EE Forum 2011

Internet Explorer Architectural Overview

Jason Weber, PDC 2011

W3C Web Performance

Web Performance Working Group Homepage

Performance Timeline Specification

Navigation Timing Specification

Blog Posts


WPT Standalone SDK

Windows Performance Toolkit

Fiddler Web Debugger


Evolution of .NET Framework


.NET Framework


CLR 4.0

.NET 4.5



Portable Class Libraries

.NET 4.0

Parallel Computing


Covariance and


CLR 2.0

.NET 3.5 SP1


Entity Framework

LINQ to Entities

Cloud Computing

.NET 3.5







LINQ to Objects

.NET 3.0





.NET 2.0




CLR 1.0

.NET 1.1

.NET 1.0





Switching between Running Apache and IIS in Windows



When one installs Apache in Windows Machine where IIS is installed, starting Apache will give the following error :

The Apache service named  reported the following error:
>>> (OS 10013) An attempt was made to access a socket in a way forbidden by its access permissions.
:make_sock: could not bind to address

The reason is both the servers listen on Port 80. Even though you can make one of the servers to listen in different port it is too many changes to make things work.

Easier way is to have these servers running alternatively using simple batch scripts.

Apache and IIS are both launched as a Windows service — open Administrative Tools > Services. Locate Apache and IIS (W3SVC – World Wide Web Publishing Service) and set both Startup types to Manual:

IIS TCP port bindings

(Make a note of Apache’s service name — in the screenshot above, it’s “Apache2.2″.)

Neither server will run when your PC is booted. To start and stop the services, create 4 batch (.bat) files in the same folder.

This will stop IIS and start/restart Apache. (Note that ‘Apache’ is assumed to be the service name in the third line, but your installation may be different.)

@call stop-iis.bat
@call stop-apache.bat
@net start Apache

This will stop Apache (change the service name if necessary).

@net stop Apache

This will stop Apache and start/restart IIS.

@call stop-apache.bat
@call stop-iis.bat
@net start W3SVC

This will stop IIS on Windows Vista or 7.

@net stop was /y

This will stop IIS on Windows XP or earlier.

@net stop iisadmin /y

You can double-click these files to run them or create desktop / start menu shortcuts for easier access.

Source :

C# Coding Guidelines


If you are looking for C# Coding Guidelines grab these guidelines from

I have listed the important ones here.

Basic Principles of Coding

Class Design

  • A class or interface should have a single purpose (AV1000)
  • An interface should be small and focused (AV1003)
  • Use an interface to decouple classes from each other (AV1005)
  • Don’t hide inherited members with the new keyword (AV1010)
  • It should be possible to treat a derived object as if it were a base class object (AV1011)
  • Don’t refer to derived classes from the base class (AV1013)
  • Avoid exposing the objects an object depends on (AV1014)
  • Avoid bidirectional dependencies (AV1020)
  • Classes should have state and behavior (AV1025)

Member Design

  • Allow properties to be set in any order (AV1100)
  • Avoid mutual exclusive properties (AV1110)
  • A method or property should do only one thing (AV1115)
  • Don’t expose stateful objects through static members (AV1125)
  • Return an IEnumerable or ICollection instead of a concrete collection class (AV1130)
  • String, list and collection properties should never return a null reference (AV1135)

Miscellaneous Design

  • Throw exceptions rather than returning status values (AV1200)
  • Provide a rich and meaningful exception message text (AV1202)
  • Don’t swallow errors by catching generic exceptions (AV1210)
  • Always check an event handler delegate for null (AV1220)
  • Use a protected virtual method to raise each event (AV1225)
  • Don’t pass null as the sender parameter when raising an event (AV1235)
  • Use generic constraints if applicable (AV1240)
  • Don’t add extension methods to the same namespace as the extended class (AV1245)
  • Evaluate the result of a LINQ expression before returning it (AV1250)


  • Methods should not exceed 7 statements (AV1500)
  • Make all members private and types internal by default (AV1501)
  • Avoid conditions with double negatives (AV1502)
  • Don’t use “magic numbers” (AV1515)
  • Only use var when the type is very obvious (AV1520)
  • Initialize variables at the point of declaration (AV1521)
  • Favor Object and Collection Initializers over separate statements (AV1523)
  • Don’t make explicit comparisons to true or false (AV1525)
  • Don’t use nested loops in a method (AV1532)
  • Add a block after all flow control keywords, even if it is empty (AV1535)
  • Always add a default block after the last case in a switch statement (AV1536)
  • Finish every if-else-if statement with an else-part (AV1537)
  • Be reluctant with multiple return statements (AV1540)
  • Don’t use selection statements instead of a simple assignment or initialization (AV1545)
  • Prefer conditional statements instead of simple if-else constructs (AV1546)
  • Encapsulate complex expressions in a method or property (AV1547)
  • Call the most overloaded method from other overloads (AV1551)
  • Only use optional parameters to replace overloads (AV1553)
  • Avoid using named parameters (AV1555)
  • Avoid methods with more than three parameters (AV1561)
  • Don’t use ref or out parameters (AV1562)
  • Avoid methods that take a bool flag (AV1564)
  • Always check the result of an as operation (AV1570)
  • Don’t comment-out code (AV1575)
  • Consider abstracting an external dependency or 3rd party component (AV1580)

Framework Guidelines

  • Use C# type aliases instead of the types from the System namespace (AV2201)
  • Build with the highest warning level (AV2210)
  • Use Lambda expressions instead of delegates (AV2221)
  • Only use the dynamic keyword when talking to a dynamic object (AV2230)


WCF Data Services Vs ASP.NET Web API OData


If you are struggling with picking WCF Data Services/ ASP.NET Web API OData here are the high level key differences between these 2 implementation stacks.

WCF Data Services ASP.NET Web API OData
Architecture Interfaces Components
Server / Client? Server and Client Server only
Maturity Released Preview
OData coverage Full Partial, more coming
Flexibility Low High
Key requirements IQueryable -
Custom business logic Medium Easy
Formats OData only Any format
Untyped Yes No




REST (Representational State Transfer) and SOAP (Simple Object Access Protocol) represent two very different styles to implement a Web Service. There is a whole lot of analysis done on what to use.. Here is my understanding.

REST represents an architecture style and is designed to reduce complexity by dividing the system into resources. The resources and operations supported by a resource are represented and exposed through a set of URIs (HTTP addresses) logically on the HTTP protocol.

SOAP is a protocol based on messages that is used to implement the messages layer of a Web Service. The message consists of an “envelope” with a header and a body. The header can be used to provide information external to the operation to be performed by the service (e.g., security aspects, transactional aspects or message routing, included in the header).

The main difference between these two approaches is the how the service state is maintained.

With SOAP, changing through different states is made by interacting with a single service endpoint which encapsulates many operations and message types.

With REST, we have a limited number of operations and these operations are applied to resources represented and addressed by URIs (HTTP addresses). The messages are composed by current resources states or the required resources state.

REST works very well with Web applications where HTTP can be used as protocol for data types other than XML (like JSON). The service consumers interact with the resources through URIs in the same way people can navigate and interact with Web pages through URLs (web addresses).

The following diagram shows what scenarios REST or SOAP fit better

  Advantages Disadvantages
SOAP Strongly typed proxies – WSDL SOAP messages are not „cacheable‟ by CDNs. This is a very serious handicap for high scalable applications in the Internet
SOAP Supports different communication protocols. (HTTP/TCP/MSMQ/Named
SOAP messages are not JavaScript friendly (For AJAX, JQuery, etc. REST is the best choice).
REST Services act as Resources, such as images or HTML documents Working with strongly typed objects is harder, although this depends on technological implementations and it is improving in the latest versions of most platforms
  Data can be maintained strictly or decoupled (not as strict as SOAP) Only works over HTTP, and REST calls are restricted to HTTP verbs (GET, POST, PUT, DELETE, etc.). But, it this really a disadvantage for the Internet and interoperable solutions? 
  REST resources can be easily used from the JavaScript code (AJAX, JQuery, etc.)  
  Messages are light, so the performance and scalability offered are high. This is important for many Internet applications  
  REST can use XML or JSON as data format  
  REST messages are „cacheable‟ by CDNs thanks to the HTTP GET verb being used like any HTTP-HTML web-site. This is a great advantage for high scalable applications in the Internet  


Even though both approaches (REST and SOAP) may be used for similar types of services, the approach based on REST is normally more suitable for Distributed Services that are publicly accessible (Internet) and require high scalability or in cases where a Service can be accessed by unknown consumers. SOAP, on the contrary, is still a good approach for implementing procedural implementation ranges, such as an interface between the different layers of Application architecture or, ultimately, private Business Applications.

SOAP does not limit to HTTP. The standard specification WS-*, which can be used on SOAP, provides a standard and therefore interoperable path to work with advanced aspects such as SECURITY, TRANSACTIONS, ADDRESSING AND RELIABLE-MESSAGING. But, frankly, these advanced WS-* specifications have not been broadly adopted and used by most applications in the Internet and even when they are standard specifications, its degree of compatibility between different technical platforms is not really high, mostly due to its complexity.

REST also offers a great level of interoperability (due to the simplicity of its protocol); however, for advanced aspects, such as those previously mentioned, it would be necessary to implement their own mechanisms, which would be non-standard.

In short, both protocols allow us to interchange data by using verbs.

The difference lies in the fact that, with REST, this set of verbs is restricted to coincidence with HTTP verbs (GET, PUT, etc.) and in the case of SOAP, the set of verbs is open and defined in the Service endpoint.

- SOAP is a protocol that provides a messaging framework that a layer abstraction can be built on, and it is mostly used as an RPC calls system (synchronous or asynchronous) where data is transferred as XML messages.

- SOAP manages aspects, such as security and addressing, through its internal implementation of SOAP protocol.

- REST is a technique that uses other protocols, such as JSON (JavaScript ObjectNotation) and Atom as a publication protocol, and simple and light formats of the POX type (Plain Old XML).

- REST enables the use of standard HTTP calls such as GET and PUT to make queries and modify the state of the system. REST is stateless by nature, which means each individual request sent from the client to the server must contain all the necessary information in order to understand the request, since the server will not store data about the state of the session.

SOAP is a protocol based on messages that is used to implement the messages layer of a Web Service. The message consists of an “envelope” with a header and a body. The header can be used to provide information external to the operation to be performed by the service (e.g., security aspects, transactional aspects or message routing, included in the header).

Source : MSDN


Azure Service Platform – An Introduction



These are my notes from Cloud OS Event conducted by Microsoft. It gives a high level overview of Azure service platform.

  • Industry has defined three categories of Cloud services:
    • IaaS  (Infrastructure as service) – a set of infrastructure level capabilities such as an operating system, network connectivity, etc. that are delivered as pay for use services and can be used to host applications.
    • PaaS (Platform as Service) – higher level sets of functionality that are delivered as consumable services for developers who are building applications.  PaaS is about abstracting developers from the underlying infrastructure to enable applications to quickly be composed.
    • SaaS (Software as Service) – applications that are delivered using a service delivery model where organizations can simply consume and use the application.  Typically an organization would pay for the use of the application.

Packaged Software

With packaged software a customer would be responsible for managing the entire stack – ranging from the network connectivity to the applications.  This is what we have today.

  • IaaS
    • With Infrastructure as a Service, the lower levels of the stack are managed by a vendor.  Some of these components can be provided by traditional hosters  in fact most of them have moved to having a virtualized offering.
    • The customer is still responsible for managing the OS through the Applications.
    • For the developer, an obvious benefit with IaaS is that it frees the developer from many concerns when provisioning physical or virtual machines.
  • PaaS
    • With Platform as a Service, everything from the network connectivity through the runtime is provided and managed by the platform vendor.
    • The Windows Azure best fits in this category today. 
    • PaaS offerings further reduce the developer burden by additionally supporting the platform runtime and related application services.
    • With PaaS, the developer can, almost immediately, begin creating the business logic for an application.
    • Potentially, the increases in productivity are considerable and, because the hardware and operational aspects of the cloud platform are also managed by the cloud platform provider, applications can quickly be taken from an idea to reality very quickly.
  • SaaS
    • Finally, with SaaS, a vendor provides the application and abstracts you from all of the underlying components.

Azure Storage Options – Fundamental data abstractions to build Cloud Applications

  • Blob service, for storing binary and text data
  • Queue service, for storing messages that may be accessed by a client
    • Queue service provides reliable, persistent messaging within and between services. The REST API for the Queue service exposes two resources: queues and messages.
    • Enables workflow between roles
    • Load work in a queue
    • Producer can forget about message once it is in queue
    • Many workers consume the queue
    • For extreme throughput (>500 tps)
    • Use multiple queues
    • Read messages in batches
    • Multiple work items per message
  • Table service, for structured storage for non-relational data
    • Table service provides structured storage in the form of tables.
    • Table service supports a REST API that is compliant with the ADO.NET Data Services REST API.
    • Developers may also use the .NET Client Library for ADO.NET Data Services to access the Table service.
    • Tables store data as entities.
    • An entity is a collection of named properties and their values, similar to a row.
      • Entity can have up to 255 properties
      • Up to 1MB per entity
      • Mandatory Properties for every entity
      • PartitionKey & RowKey (only indexed properties)
      • Uniquely identifies an entity
      • Defines the sort order
      • Timestamp
      • Optimistic Concurrency
      • Exposed as an HTTP Etag
      • No fixed schema for other properties
      • Each property is stored as a <name, typed value> pair
      • No schema stored for a table
      • Properties can be the standard .NET types
      • String, binary, bool, DateTime, GUID, int, int64, and double
    • Tables are partitioned to support load balancing across storage nodes.
    • Each table has as its first property a partition key that specifies the partition an entity belongs to.
    • The second property is a row key that identifies an entity within a given partition.
    • The combination of the partition key and the row key forms a primary key that identifies each entity uniquely within the table.
    • The Table service does not enforce any schema.
    • A developer may choose to implement and enforce a schema on the client side
  • Windows Azure drives, for mounting an NTFS volume accessible to code running in Windows Azure service.
    • Use existing NTFS APIs to access a network attached durable drive
    • Use System.IO from .NET
    • Benefits
      • Move existing apps using NTFS more easily to the cloud
      • Durability and survival of data on instance recycle
      • A Windows Azure Drive is an NTFS VHD Page Blob
      • Mounts Page Blob over the network as an NTFS drive
      • Local cache on instance for read operations
      • All flushed and unbuffered writes to drive are made durable to the Page Blob
  • Programmatic access to the Blob, Queue, and Table services is available via the Windows Azure Managed Library and the Windows Azure storage services REST API

Identity (Security)

  • Integrate with enterprise identity
  • Enable single sign-on within your apps
  • Enterprise Graph REST API
  • Claim Based Identity
  • Windows Azure Access Control Service
    • Host an STS in cloud for you
    • WS-Federation, WS-Trust, Open ID, OAuth

Service Bus

  • Secure messaging and relay capabilities
  • Easily build hybrid applications
  • Enable loosely coupled solutions
  • Connectivity
    • Service Relay -Rich Options for Interconnecting apps across network boundaries
  • Messaging
    • Queuing Publish/Subscribe
    • Reliable Transfer -Reliable transaction aware cloud messaging infrastructure for business applications
  • Service Management
    • Service Discovery, Monitoring
    • Integration Routing
      • Content based routing & process coordination.

Key Capabilities

  • Relayed One-Way Unicast and Multicast
  • Relayed WCF NET.TCP with Direct Connect Option
  • Relayed WCF HTTP with support for REST and SOAP 1.1/1.2
  • Endpoint protection with Access Control

Azure Usage Scenarios :

  • Ideal for Applications Needing:
    • Scalability
    • Availability
    • Fault Tolerance
    • Common Application Uses:
      • Web Sites
      • Compute Intensive apps
      • Device Applications
      • Web APIs
      • Social Games

Summary :

Windows Azure provides a comprehensive set of services to selectively compose to build cloud applications.

Global Data Center Footprint - 99.95% Monthly SLA.

Flexible & Open Compute Options - Virtual Machines, Web Sites, & Cloud Services

Managed Building Block Services - SQL Database, Cache, Service Bus.

Full list of Video and Audio formats supported in Windows 8


Supported audio and video formats

Media File Container or File Format File Extension Media Stream Formats (Codecs)
Video Audio
MPEG-4 .3g2 H.263

H.264 (Baseline, Main, High)

MPEG-4 Part2 SP and ASP

.m4a n/a AAC (LC, HE)


.m4v H.263

H.264 (Baseline, Main, High)

MPEG-4 Part2 SP and ASP

MPEG-2 .m2ts (e.g. AVCHD) H.264 MPEG-2 (L1, L2, stereo-only)

MPEG-1 (L1, L2)


AC3 (DD, DD+)

ASF .asf VC-1


WMA standard

WMA voice

WMA lossless


.wma n/a
ADTS .aac n/a AAC (LC, HE)
MP3 .mp3 n/a MP3
WAV .wav n/a PCM





MS GSM 6.10

AVI .avi MPEG-4 Part2 SP and ASP









MS GSM 6.10

AC3 (DD, DD+)

AC-3 .ac3


n/a AC3 (DD, DD+)

Source : MSDN

MVVM pain points


, , ,

MVVM was touted as THE PATTERN to go for when Microsoft introduced WPF. It got more attention when Silverlight which was a thin down version of WPF released later.

Now both the technologies are going back to the shelf does the pattern MVVM still sounds good ?. MVVM do provide a strong pattern for Data Binding, Design and Testing it also has bunch of pain points which are hightlighted below :

  • Microsoft hasn’t given clear directions on this pattern yet, and the various non­Microsoft resources available on the topic can send mixed messages, leaving developers and architects confused.
  • Need for boilerplate code, complicated techniques and/or frameworks. Things like property changed notifications and commands require lots of boilerplate code and potentially brittle designs that require using “magic strings”.  Even though there are open source frameworks available one may not want to or may not be allowed to use open source frameworks.
  • Only supported in WPF and Silverlight: This pattern doesn’t transfer well to technologies such as ASP.NET or WinForms easily.


What is new in .NET 4.5



Consolidated list of New Features in .NET 4.5 grouped by Category.

.NET 4.5 is an IN-PLACE upgrade and it comes pre-installed with Windows 8 and Windows Server 8.

Base Class Libraries (BCL)

  • Async support
    • Key Interfaces now support async
  • Improvements to
    • Networking (IPV6 enchanced, IDN, EAI)
    • WeakReferences
    • ArraySegment
    • Streams
    • ReadOnlyDictionary
    • Compression
    • CLR objects over 2GB in size
    • Resource file management performance
    • Unicode (v6, console support)
    • Task Parallel Library
      • Task thread controls Improved
        • Task.WaitAll
        • Task.WaitAny
    • TPL Dataflow
      • Tools for Parallel data flow processing

C# 5.0

  • Support for async programming
    • async and await keywords
    • Methods can access call site info as parameters (CallerInfo)


  • Support for Contract-First Development.
  • Support for flat single WSDL file
  • WebSocket support for WCF based Services (Only with Windows 8)
  •  New Bindings: NetHttpBinding and NetHttpsBinding
  • New Channels (UDP Binding (fire and forget), Websockets)
  • Multiple authorization models for HTTP endpoints
  • New simple HttpClient Class
  • Streaming Improvements.
  • Configuration improvements:
  • Tooltips , Intellisense and compile-time validation in config files
  • Generated client config files cleaned up – Only non-default binding configuration will be generated


  • Workflow Versioning
    • Basic building blocks for versioning provided by WorkflowIdentity
    • Host several versions of a service side by side
    • Update running instances to a new definition using DynamicUpdate
  • Authoring Improvements
    • Contract First Services
      • Create workflow service based on an existing contract
    • C# Expressions
    • Better experience with State Machine/Flowchart designer featuring Auto-connect, Auto-insert and Panning
  • Faster execution
  • State machines
  • Runtime
    • Improved Performance
    • Run workflows in Partial Trust
    • Expressions Extensibility – Ability to plug custom expressions.
  • Designer Improvements
    • Search
    • Performance
    • Usability
    • Better Integration with VS


  • Built-in Ribbon controls
  • Databinding Improvements.
  • Ability to add breakpoints to databindings.
  • Datasource change aware views
  • Improved performance when displaying large amount of data
  • MVVM Improvements
  • Validation Improvements
  • Dispatcher Improvements
  • Designer improvements: VS11 has the same design engine as Expression Blend


Example : TextMode property of the TextBox control support new HTML 5 input types like email, datetime

  • Multiple support for FileUpload Control
  • Validator and UpdatePanel now support for new HTML5 elements
  • Performance
    • Performance Improvement for ASP.NET Web Hosting
      • Faster ASP.NET Startup (multi-core JIT compilation, sharing common assemblies)
      • Reduced memory footprint (tuning of GC with 1 single setting)
    • Up to 35% performance in combination with Windows 8 Server (prefetching feature)


  • Support for Generic parts
  • Support for binding POCOs. Attribute requirements removed.
  • Explicit and convention based binding between objects.
  • MEF problems are easy to diagnose
    • Break on First Chance Exceptions
    • Visualize the exception

Entity Framework 4.5 Features

  • Enums
  • Spatial Data
  • Table-Valued Functions
  • Sprocs with multiple result sets
  • Automatic compiled LINQ queries
  • Query optimization improvements
  • Multiple Diagram Support
  • Database Project integration

Visual Studio 11 Improvements for web developers

Windows RT 101




There are lot of confusion and questions around Windows 8, WinRT..

Let us break this down here.

This is the full stack.

Windows 8 Core OS Services is the core kernel which is same as in Windows 7 with rewrite in some areas and complete improvements in many areas.

 Desktop Apps runs only on x86 or x64. It will not run in ARM devices where Windows RT only is present. However it will work in Surface tablet with Intel Processors where the Core is the full Windows 8 OS.

Any application which is written and which will be written using the language stack listed below HTML, Javascript, C, C++, C#, VB which uses .NET / IE / Win32 / Silverlight or Silverlight for Windows Phone will run only in Desktop mode in Windows 8. This will not have access to Win RT goodies like sharing/search.

WinRT API’s which is sitting on top of WinRT Core is similar like .NET which is sitting in top of OS.

Key feature of WinRT is the language projection & metadata which allows the WinRT API to be  consumed natively by the languages stack(.NET for Win RT, WinJS) listed above. Note WinJS is meant only for WinRT and it will run by itself in a web stack.

Apps built on top of the WinRT API are the Windows Apps which run in Windows 8 OS and in Windows 8 Tablets.


Enterprise Application Sample for Windows Azure





Microsoft has released an end to end enterprise application sample for Windows Azure and Microsoft cloud technologies.

It is a service-oriented application based on the .NET Framework 4.0, including ASP.NET and Windows Communication Foundation (WCF).

It illustrates many of the .NET enterprise development technologies that can be used for building highly scalable, “cloud-connected” applications.

The application demonstrates a single code base that works on traditional servers, Hyper-V private clouds, and in the Windows Azure public cloud, including hybrid cloud scenarios.

The download includes the automated setup for the .NET StockTrader 5.5 and the Configuration Service 5.5, with associated technical documents that explain how to run and reconfigure the .NET StockTrader service-oriented application. Additional documentation in the download provides the steps necessary to implement the Configuration Service 5.5 in your own applications and services for central configuration management; distributed caching; load-balancing and failover across clustered service nodes. The sample includes:

· .NET StockTrader 5.5 composite Web application and middle tier services.
· Optional Windows Azure Projects for deploying to the cloud.
· New modes for Advanced Web Service (WS-*) message-level security and interoperability with a variety of non-Microsoft platforms via the SOA architecture.
· Configuration Service 5.5 with technical guides and samples.
· Capacity planning tool for running multi-agent benchmarks against the .NET StockTrader services.
· WSTest 1.5 Web services benchmark.



Windows 8 Locales – Complete list

If you are looking for the list of locales Windows 8 here they are..

Name Display Name Native Name
af-ZA Afrikaans (South Africa) Afrikaans (Suid-Afrika)
am-ET Amharic (Ethiopia) አማርኛ (ኢትዮጵያ)
ar-AE Arabic (U.A.E.) العربية (الإمارات العربية المتحدة)
ar-BH Arabic (Bahrain) العربية (البحرين)
ar-DZ Arabic (Algeria) العربية (الجزائر)
ar-EG Arabic (Egypt) العربية (مصر)
ar-IQ Arabic (Iraq) العربية (العراق)
ar-JO Arabic (Jordan) العربية (الأردن)
ar-KW Arabic (Kuwait) العربية (الكويت)
ar-LB Arabic (Lebanon) العربية (لبنان)
ar-LY Arabic (Libya) العربية (ليبيا)
ar-MA Arabic (Morocco) العربية (المملكة المغربية)
arn-CL Mapudungun (Chile) Mapudungun (Chile)
ar-OM Arabic (Oman) العربية (عمان)
ar-QA Arabic (Qatar) العربية (قطر)
ar-SA Arabic (Saudi Arabia) العربية (المملكة العربية السعودية)
ar-SY Arabic (Syria) العربية (سوريا)
ar-TN Arabic (Tunisia) العربية (تونس)
ar-YE Arabic (Yemen) العربية (اليمن)
as-IN Assamese (India) অসমীয়া (ভাৰত)
az-Cyrl-AZ Azeri (Cyrillic, Azerbaijan) Азәрбајҹан (Азәрбајҹан)
az-Latn-AZ Azeri (Latin, Azerbaijan) Azərbaycan dili (Azərbaycan)
ba-RU Bashkir (Russia) Башҡорт (Рәсәй)
be-BY Belarusian (Belarus) Беларуская (Беларусь)
bg-BG Bulgarian (Bulgaria) български (България)
bn-BD Bengali (Bangladesh) বাংলা (বাংলাদেশ)
bn-IN Bengali (India) বাংলা (ভারত)
bo-CN Tibetan (PRC) བོད་ཡིག (ཀྲུང་ཧྭ་མི་དམངས་སྤྱི་མཐུན་རྒྱལ་ཁབ།)
br-FR Breton (France) brezhoneg (Frañs)
bs-Cyrl-BA Bosnian (Cyrillic, Bosnia and Herzegovina) босански (Босна и Херцеговина)
bs-Latn-BA Bosnian (Latin, Bosnia and Herzegovina) bosanski (Bosna i Hercegovina)
ca-ES Catalan (Catalan) Català (Català)
ca-ES-valencia Valencian (Spain) Valencià (Espanya)
chr-Cher-US Cherokee (Cherokee) ᏣᎳᎩ (ᏣᎳᎩ)
co-FR Corsican (France) Corsu (Francia)
cs-CZ Czech (Czech Republic) čeština (Česká republika)
cy-GB Welsh (United Kingdom) Cymraeg (Y Deyrnas Unedig)
da-DK Danish (Denmark) dansk (Danmark)
de-AT German (Austria) Deutsch (Österreich)
de-CH German (Switzerland) Deutsch (Schweiz)
de-DE German (Germany) Deutsch (Deutschland)
de-LI German (Liechtenstein) Deutsch (Liechtenstein)
de-LU German (Luxembourg) Deutsch (Luxemburg)
dsb-DE Lower Sorbian (Germany) dolnoserbšćina (Nimska)
dv-MV Divehi (Maldives) ދިވެހިބަސް (ދިވެހި ރާއްޖެ)
el-GR Greek (Greece) Ελληνικά (Ελλάδα)
en-029 English (Caribbean) English (Caribbean)
en-AU English (Australia) English (Australia)
en-BZ English (Belize) English (Belize)
en-CA English (Canada) English (Canada)
en-GB English (United Kingdom) English (United Kingdom)
en-IE English (Ireland) English (Ireland)
en-IN English (India) English (India)
en-JM English (Jamaica) English (Jamaica)
en-MY English (Malaysia) English (Malaysia)
en-NZ English (New Zealand) English (New Zealand)
en-PH English (Republic of the Philippines) English (Philippines)
en-SG English (Singapore) English (Singapore)
en-TT English (Trinidad and Tobago) English (Trinidad and Tobago)
en-US English (United States) English (United States)
en-ZA English (South Africa) English (South Africa)
en-ZW English (Zimbabwe) English (Zimbabwe)
es-AR Spanish (Argentina) Español (Argentina)
es-BO Spanish (Bolivia) Español (Bolivia)
es-CL Spanish (Chile) Español (Chile)
es-CO Spanish (Colombia) Español (Colombia)
es-CR Spanish (Costa Rica) Español (Costa Rica)
es-DO Spanish (Dominican Republic) Español (República Dominicana)
es-EC Spanish (Ecuador) Español (Ecuador)
es-ES Spanish (Spain) Español (España, alfabetización internacional)
es-GT Spanish (Guatemala) Español (Guatemala)
es-HN Spanish (Honduras) Español (Honduras)
es-MX Spanish (Mexico) Español (México)
es-NI Spanish (Nicaragua) Español (Nicaragua)
es-PA Spanish (Panama) Español (Panamá)
es-PE Spanish (Peru) Español (Perú)
es-PR Spanish (Puerto Rico) Español (Puerto Rico)
es-PY Spanish (Paraguay) Español (Paraguay)
es-SV Spanish (El Salvador) Español (El Salvador)
es-US Spanish (United States) Español (Estados Unidos)
es-UY Spanish (Uruguay) Español (Uruguay)
es-VE Spanish (Bolivarian Republic of Venezuela) Español (Republica Bolivariana de Venezuela)
et-EE Estonian (Estonia) eesti (Eesti)
eu-ES Basque (Basque) euskara (euskara)
fa-IR Persian فارسى (ایران)
ff-Latn-SN Fulah (Latin, Senegal) Fulah (Sénégal)
fi-FI Finnish (Finland) suomi (Suomi)
fil-PH Filipino (Philippines) Filipino (Pilipinas)
fo-FO Faroese (Faroe Islands) føroyskt (Føroyar)
fr-BE French (Belgium) français (Belgique)
fr-CA French (Canada) français (Canada)
fr-CH French (Switzerland) français (Suisse)
fr-FR French (France) français (France)
fr-LU French (Luxembourg) français (Luxembourg)
fr-MC French (Monaco) français (Principauté de Monaco)
fy-NL Frisian (Netherlands) Frysk (Nederlân)
ga-IE Irish (Ireland) Gaeilge (Éire)
gd-GB Scottish Gaelic (United Kingdom) Gàidhlig (An Rìoghachd Aonaichte)
gl-ES Galician (Galician) galego (galego)
gsw-FR Alsatian (France) Elsässisch (Frànkrisch)
gu-IN Gujarati (India) ગુજરાતી (ભારત)
ha-Latn-NG Hausa (Latin, Nigeria) Hausa (Nijeriya)
haw-US Hawaiian (United States) Hawaiʻi (ʻAmelika)
he-IL Hebrew (Israel) עברית (ישראל)
hi-IN Hindi (India) हिंदी (भारत)
hr-BA Croatian (Latin, Bosnia and Herzegovina) hrvatski (Bosna i Hercegovina)
hr-HR Croatian (Croatia) hrvatski (Hrvatska)
hsb-DE Upper Sorbian (Germany) hornjoserbšćina (Němska)
hu-HU Hungarian (Hungary) magyar (Magyarország)
hy-AM Armenian (Armenia) Հայերեն (Հայաստան)
id-ID Indonesian (Indonesia) Bahasa Indonesia (Indonesia)
ig-NG Igbo (Nigeria) Igbo (Nigeria)
ii-CN Yi (PRC) ꆈꌠꁱꂷ (ꍏꉸꏓꂱꇭꉼꇩ)
is-IS Icelandic (Iceland) íslenska (Ísland)
it-CH Italian (Switzerland) italiano (Svizzera)
it-IT Italian (Italy) italiano (Italia)
iu-Cans-CA Inuktitut (Syllabics, Canada) ᐃᓄᒃᑎᑐᑦ (ᑲᓇᑕᒥ)
iu-Latn-CA Inuktitut (Latin, Canada) Inuktitut (Kanatami)
ja-JP Japanese (Japan) 日本語 (日本)
ka-GE Georgian (Georgia) ქართული (საქართველო)
kk-KZ Kazakh (Kazakhstan) Қазақ (Қазақстан)
kl-GL Greenlandic (Greenland) kalaallisut (Kalaallit Nunaat)
km-KH Khmer (Cambodia) ភាសាខ្មែរ (កម្ពុជា)
kn-IN Kannada (India) ಕನ್ನಡ (ಭಾರತ)
kok-IN Konkani (India) कोंकणी (भारत)
ko-KR Korean (Korea) 한국어(대한민국)
ku-Arab-IQ Central Kurdish (Iraq) کوردیی ناوەڕاست (کوردستان)
ky-KG Kyrgyz (Kyrgyzstan) Кыргыз (Кыргызстан)
lb-LU Luxembourgish (Luxembourg) Lëtzebuergesch (Lëtzebuerg)
lo-LA Lao (Lao P.D.R.) ພາສາລາວ (ສປປ ລາວ)
lt-LT Lithuanian (Lithuania) lietuvių (Lietuva)
lv-LV Latvian (Latvia) latviešu (Latvija)
mi-NZ Maori (New Zealand) Reo Māori (Aotearoa)
mk-MK Macedonian (Former Yugoslav Republic of Macedonia) македонски јазик (Македонија)
ml-IN Malayalam (India) മലയാളം (ഭാരതം)
mn-MN Mongolian (Cyrillic, Mongolia) Монгол хэл (Монгол улс)
mn-Mong-CN Mongolian (Traditional Mongolian, PRC) ᠮᠤᠨᠭᠭᠤᠯ ᠬᠡᠯᠡ (ᠪᠦᠭᠦᠳᠡ ᠨᠠᠢᠷᠠᠮᠳᠠᠬᠤ ᠳᠤᠮᠳᠠᠳᠤ ᠠᠷᠠᠳ ᠣᠯᠣᠰ)
moh-CA Mohawk (Mohawk) Kanien’kéha
mr-IN Marathi (India) मराठी (भारत)
ms-BN Malay (Brunei Darussalam) Bahasa Melayu (Brunei Darussalam)
ms-MY Malay (Malaysia) Bahasa Melayu (Malaysia)
mt-MT Maltese (Malta) Malti (Malta)
nb-NO Norwegian, Bokmål (Norway) norsk, bokmål (Norge)
ne-NP Nepali (Nepal) नेपाली (नेपाल)
nl-BE Dutch (Belgium) Nederlands (België)
nl-NL Dutch (Netherlands) Nederlands (Nederland)
nn-NO Norwegian, Nynorsk (Norway) norsk, nynorsk (Noreg)
nso-ZA Sesotho sa Leboa (South Africa) Sesotho sa Leboa (Afrika Borwa)
oc-FR Occitan (France) Occitan (França)
or-IN Oriya (India) ଓଡ଼ିଆ (ଭାରତ)
pa-Arab-PK Punjabi (Islamic Republic of Pakistan) پنجابی (پاکستان)
pa-IN Punjabi (India) ਪੰਜਾਬੀ (ਭਾਰਤ)
pl-PL Polish (Poland) polski (Polska)
prs-AF Dari (Afghanistan) درى (افغانستان)
ps-AF Pashto (Afghanistan) پښتو (افغانستان)
pt-BR Portuguese (Brazil) Português (Brasil)
pt-PT Portuguese (Portugal) português (Portugal)
qut-GT K’iche (Guatemala) K’iche’ (Guatemala)
quz-BO Quechua (Bolivia) runasimi (Qullasuyu)
quz-EC Quechua (Ecuador) runa shimi (Ecuador Suyu)
quz-PE Quechua (Peru) runasimi (Peru)
rm-CH Romansh (Switzerland) Rumantsch (Svizra)
ro-RO Romanian (Romania) română (România)
ru-RU Russian (Russia) русский (Россия)
rw-RW Kinyarwanda (Rwanda) Kinyarwanda (Rwanda)
sah-RU Sakha (Russia) Саха (Россия)
sa-IN Sanskrit (India) संस्कृत (भारतम्)
sd-Arab-PK Sindhi (Islamic Republic of Pakistan) سنڌي (پاکستان)
se-FI Sami, Northern (Finland) davvisámegiella (Suopma)
se-NO Sami, Northern (Norway) davvisámegiella (Norga)
se-SE Sami, Northern (Sweden) davvisámegiella (Ruoŧŧa)
si-LK Sinhala (Sri Lanka) සිංහල (ශ්‍රී ලංකා)
sk-SK Slovak (Slovakia) slovenčina (Slovenská republika)
sl-SI Slovenian (Slovenia) slovenski (Slovenija)
sma-NO Sami, Southern (Norway) åarjelsaemiengïele (Nöörje)
sma-SE Sami, Southern (Sweden) åarjelsaemiengïele (Sveerje)
smj-NO Sami, Lule (Norway) julevusámegiella (Vuodna)
smj-SE Sami, Lule (Sweden) julevusámegiella (Svierik)
smn-FI Sami, Inari (Finland) sämikielâ (Suomâ)
sms-FI Sami, Skolt (Finland) sää´mǩiõll (Lää´ddjânnam)
sq-AL Albanian (Albania) Shqip (Shqipëria)
sr-Cyrl-BA Serbian (Cyrillic, Bosnia and Herzegovina) српски (Босна и Херцеговина)
sr-Cyrl-CS Serbian (Cyrillic, Serbia and Montenegro (Former)) српски (Србија и Црна Гора (Бивша))
sr-Cyrl-ME Serbian (Cyrillic, Montenegro) српски (Црна Гора)
sr-Cyrl-RS Serbian (Cyrillic, Serbia) српски (Србија)
sr-Latn-BA Serbian (Latin, Bosnia and Herzegovina) srpski (Bosna i Hercegovina)
sr-Latn-CS Serbian (Latin, Serbia and Montenegro (Former)) srpski (Srbija i Crna Gora (Bivša))
sr-Latn-ME Serbian (Latin, Montenegro) srpski (Crna Gora)
sr-Latn-RS Serbian (Latin, Serbia) srpski (Srbija)
sv-FI Swedish (Finland) svenska (Finland)
sv-SE Swedish (Sweden) svenska (Sverige)
sw-KE Kiswahili (Kenya) Kiswahili (Kenya)
syr-SY Syriac (Syria) ܣܘܪܝܝܐ (ܣܘܪܝܐ)
ta-IN Tamil (India) தமிழ் (இந்தியா)
ta-LK Tamil (Sri Lanka) தமிழ் (இலங்கை)
te-IN Telugu (India) తెలుగు (భారత దేశం)
tg-Cyrl-TJ Tajik (Cyrillic, Tajikistan) Тоҷикӣ (Тоҷикистон)
th-TH Thai (Thailand) ไทย (ไทย)
ti-ER Tigrinya (Eritrea) ትግርኛ (ኤርትራ)
ti-ET Tigrinya (Ethiopia) ትግርኛ (ኢትዮጵያ)
tk-TM Turkmen (Turkmenistan) Türkmen dili (Türkmenistan)
tn-BW Setswana (Botswana) Setswana (Botswana)
tn-ZA Setswana (South Africa) Setswana (Aforika Borwa)
tr-TR Turkish (Turkey) Türkçe (Türkiye)
tt-RU Tatar (Russia) Татар (Россия)
tzm-Latn-DZ Tamazight (Latin, Algeria) Tamazight (Djazaïr)
tzm-Tfng-MA Central Atlas Tamazight (Tifinagh, Morocco) ⵜⴰⵎⴰⵣⵉⵖⵜ (ⵍⵎⵖⵔⵉⴱ)
ug-CN Uyghur (PRC) ئۇيغۇرچە (جۇڭخۇا خەلق جۇمھۇرىيىتى)
uk-UA Ukrainian (Ukraine) українська (Україна)
ur-PK Urdu (Islamic Republic of Pakistan) اُردو (پاکستان)
uz-Cyrl-UZ Uzbek (Cyrillic, Uzbekistan) Ўзбекча (Ўзбекистон Республикаси)
uz-Latn-UZ Uzbek (Latin, Uzbekistan) O’zbekcha (O’zbekiston Respublikasi)
vi-VN Vietnamese (Vietnam) Tiếng Việt (Việt Nam)
wo-SN Wolof (Senegal) Wolof (Senegaal)
xh-ZA isiXhosa (South Africa) isiXhosa (uMzantsi Afrika)
yo-NG Yoruba (Nigeria) Yoruba (Nigeria)
zh-CN Chinese (Simplified, PRC) 中文(中华人民共和国)
zh-HK Chinese (Traditional, Hong Kong S.A.R.) 中文(香港特別行政區)
zh-MO Chinese (Traditional, Macao S.A.R.) 中文(澳門特別行政區)
zh-SG Chinese (Simplified, Singapore) 中文(新加坡)
zh-TW Chinese (Traditional, Taiwan) 中文(台灣)
zu-ZA isiZulu (South Africa) isiZulu (iNingizimu Afrika)

Source : MSDN

Windows 8 – Power Keys – Keyboard shortcuts for Key Items



Getting to Windows Features like Programs & Features, Disk Management can be done with Windows Key + X and then pressing any one of the following will bring out the listed features below.

  • f – for programs and features (a.k.a. Add/Remove programs)
  • o – for Power Options
  • v – for Event Viewer
  • y – for System Properties (I still use WIN+BREAK)
  • m – for Device Manager
  • k – for Disk Management
  • g – for Computer Management
  • c – for the Command Prompt
  • a – for a Command Prompt running with Admin rights


This brings up the following menu:


The underlined letter of each entry allows you to follow WIN+X with

  • f – for programs and features (a.k.a. Add/Remove programs)
  • o – for Power Options
  • v – for Event Viewer
  • y – for System Properties (I still use WIN+BREAK)
  • m – for Device Manager
  • k – for Disk Management
  • g – for Computer Management
  • c – for the Command Prompt
  • a – for a Command Prompt running with Admin rights
  • t – for Task Manger
  • p – for Control Panel
  • e – for File Explorer
  • s – Search (this drops you into the Start screen’s all “Apps” view ready to search for pick an app from the list
  • r – Run (Still prefer WIN+R)
  • d – for Desktop (Still prefer WIN+D)

Related articles

Originally posted on eknowledger:

In this post I’ll go through some of the enhancements and improvements done by the CLR team as part of the performance improvements in .Net 4.5. In most cases developers will not have to do anything different to take advantage of the new stuff, it will just works whenever the new framework libraries are used.

Improved Large Object heap Allocator

I’ll start by the most “asked-for” feature from the community – compaction on LOH. As you may know the .Net CLR has a very tough classification regime for its citizens(objects) any object that is greater than or equal to 85.000 bytes considered to be special(large Object) and needs different treatment and placement, that’s why the CLR allocate a special heap for those guys and then the poor guys lives in a different heap frankly called Small Object Heap (SOH).

SOH Allocations and Garbage Collections

The main difference between these two communities are basically around how…

View original 898 more words

Installing Windows 8 in Windows 7 box with Dual boot option


, ,

I have written a post before about installing Windows 8 RC on a VHD and dual booting it.   Now Windows 8 RTM version is available (MSDN Subscribers) only at this point of time. General availability is expected on October 26th.

Steps to Install Windows 8 on a Windows 7 Box.

1. Open Device Manager from the Windows Control Panel or simply type devmgmt.msc from the command prompt or Windows -> Run.

2. Create a Partition by Shrinking the volume.

3. Specify the amount of space to shrink from the available space displayed.

4. Now specify a drive for the new Volume.

5. Create a Windows 8 Install Media. If you want to install Windows 8 from a USB Drive d ownload the Windows 7 USB/DVD download tool and follow the steps in the tool to load the image into the USB drive.

6. During the installation select the option to Install as a new install (Do not select Upgrade).

7. Install Windows 8 on the newly created volume (Step 4).

Now Windows 8 will be installed and you have the dual boot option to Windows 7/Windows 8.

WPF – Is it coming to an End ?


WPF is the only platform for desktop applications now and clearly the development community is in cross roads now as there is no roadmap from Microsoft for the future of WPF or its replacement. WinRT is projected as the next desktop/mobile platform but not is it where everyone needs to jump on ?

This article from Scott Barnes who was a program manager for WPF/Silverlight throws some light on this topic.

The consequences of declaring WPF is dead. 

Related articles

Top Classic Mistakes that kill Software Projects


Summary of Classic Mistakes

People-Related Mistakes Process-Related Mistakes Product-Related Mistakes Technology-Related Mistakes
Undermined motivation Overly optimistic schedules, Insufficient risk management, Contractor failure Requirements gold-plating Silver-bullet syndrome
Uncontrolled problem employees Insufficient planning Developer gold-plating Overestimated savings from new tools or methods
Heroics Abandonment of planning under pressure Research-oriented development Switching tools in the middle of a project
Adding people late to the project Wasted time during the fuzzy front end Feature creep Lack of automated source-code co
Noisy, crowded offices Shortchanged upstream activities Push me, pull me negotiation  
Friction between developers and customers Inadequate design    
Unrealistic expectations Shortchanged quality assurance    
Lack of effective project sponsorship Insufficient management controls    
Lack of stakeholder buy-in Premature or too frequent convergence    
Lack of user input Omitting necessary tasks from estimates    
Politics placed over substance Planning to catch up later    
Wishful thinking Code-like-hell programming    

Read the whole article from Steven C. McConnell here.


Quality Attributes – A Primer


, ,

Quality is the most common word used everywhere.. In software development this is the most talked about word. I wanted to list out the most important attributes of quality related to Design, Run Time and Usability.

Design Quality Attributes


Availability defines the proportion of time that the system is functional and working.

Availability is measured as a percentage of the total system downtime over a predefined period.

Typical factors affecting availability are System Errors, Infrastructure issues and System Load.

Things to Consider:

  • Load and Throughput of the system. Always design for 50x capacity, Implement for 3x, Deploy for 1x.
  • System Resiliency. Consider using the Circuit Breaker or Bulkhead patterns to increase system resiliency.
  • Inappropriate use of resources & Concurrency. Acquire resource late and release early.
  • Have a good exception handling mechanism to reduce application failures from which it is difficult to recover.
  • Always design for network faults and unreliable network connections.  A network fault can cause the application to be unavailable.
  • Consider the trust boundaries within your application and ensure that subsystems have some form of access control or firewall, as well as extensive data validation, to increase resiliency and availability.

Conceptual Integrity

Conceptual integrity defines the consistency and coherence of the overall design. This includes the way that components or modules are designed, as well as factors such as coding style and variable naming.

A coherent system is easier to maintain because you will know what is consistent with the overall design.

Things to Consider:

  • Separate areas of concern within the system and group them into appropriate layers (Business/Data/Service)
  • Establish a standard development process including published guidelines, standards for design and coding and a review process to make sure the published guidelines and standards are followed.
  • Isolate applications from external dependencies.
  • Create a migration plan for legacy systems and consider using the Gateway design pattern for integration with legacy systems.


Maintainability is the ability of the system to undergo changes with a degree of ease.

Things to Consider

  • Avoid tight coupling/ dependencies between components and layers. Consider implementing cross-layer dependencies by using abstractions (such as abstract classes or interfaces) rather than concrete classes, and minimize dependencies between components and layers.
  • Strive for creating pluggable architecture (Eg.PRISM).
  • Do not create custom implementations for authentication & authorization. Use standards and built in functions/tools always.
  • Separation of concerns. Always plan for change and keep the volatile changes separately. Keep the business rules/process/logic separately in its own layer.
  • Have proper documentation of the design and interactions.


Manageability defines how easy it is for system administrators to manage the application, usually through sufficient and useful instrumentation exposed for use in monitoring systems and for debugging and performance tuning.

Things to Consider

  • Create a health model that defines the significant state changes that can affect application performance, and use this model to specify instrumentation requirements.
  • Implement instrumentation, such as events and performance counters, that detects state changes, and expose these changes through standard systems such as Event Logs, Trace files, or WMI.
  • Create an Application management pack which provides accurate monitoring, debugging and management of the system.


Performance is an indication of the responsiveness of a system to execute specific actions in a given time interval. It can be measured in terms of latency or  throughput.

Latency is the time taken to respond to any event.

Throughput is the number of events that take place in a given amount of time.

Things to Consider:

  • Reduce cross process communication using coarse-grained interfaces which require minimum number of calls to execute a specific task.
  • Use Asynchronous communication as often as possible.
  • Design an efficient and appropriate caching strategy.
  • Choose effective types of transactions, locks, threading, and queuing .
  • Avoid fetching all data only  when a portion of the data is displayed.
  • Design for high performance communication between tiers by reducing the number of transitions across boundaries  and minimizing the amount of data sent over the network.


Reliability is the ability of a system to continue operating in the expected way over time. Reliability is measured as the probability that a system will not fail and that it will perform its intended function for a specified time interval.

Things to Consider:

Identify ways to detect failures and automatically initiate a failover, or redirect load to a spare or backup system.

  • Implement instrumentation, such as events and performance counters, that detects poor performance or failures of requests sent to external systems.
  • Always Log performance and auditing information about calls made to other systems and services.
  • Identify ways to handle unreliable external systems, failed communications, and failed transactions.
  • Consider how you can take the system offline but still queue pending requests.
  • Implement store and forward or cached message-based communication systems that allow requests to be stored when the target system is unavailable, and replayed when it is online.


Reusability is the probability that a component will be used in other components or  scenarios to add new functionality with little or no change. Reusability minimizes the duplication of components and the implementation time.

Things to Consider:

  • Examine the application design to identify common functionality, and implement this functionality in separate components that you can reuse.
  • Examine the application design to identify crosscutting concerns such as validation, logging, and authentication, and implement these functions as separate components.
  • Use platform agnostic data types and structures that can be accessed and understood on different platforms.


Scalability is ability of a system to either handle increases in load without impact on the performance of the system, or the ability to be readily enlarged.

There are two methods for improving scalability:

Scaling vertically (scale up) – You add more resources such as CPU, memory, and disk to a single system.

Scaling horizontally (scale out) –  To scale horizontally, you add more machines to a farm that runs the application and shares the load.

Things to Consider

  • Consider partitioning data across more than one database server to maximize scale-up opportunities and allow flexible location of data subsets.
  • Avoid stateful components and subsystems where possible to reduce server affinity.
  • Consider how you will handle spikes in traffic and load.
  • Consider implementing code that uses additional or alternative systems when it detects a predefined service load or a number of pending requests to an existing system.
  • Implement store-and-forward or cached message-based communication systems that allow requests to be stored when the target system is unavailable, and replayed when it is online.


Security is the capability of a system to reduce the chance of malicious or accidental actions outside of the designed usage. The features used to secure systems are authentication, encryption, auditing, and logging

Things to Consider:

  • Use authentication and authorization to prevent spoofing of user identity. Identify trust boundaries, and authenticate and authorize users crossing a trust boundary.
  • Damage caused by malicious input such as SQL injection and cross-site scripting. Protect against such damage by ensuring that you validate all input for length, range, format, and type using the constrain, reject, and sanitize principles.
  •  Encode all output displayed to users.
  • Data tampering. Partition the site into anonymous, identified, and authenticated users and use application instrumentation to log and expose behavior that can be monitored.
  • Use instrumentation to audit and log all user interaction for application critical operations.
  • Design all aspects of the application to prevent access to or exposure of sensitive system and application


Supportability is the ability of the system to provide information helpful for identifying and resolving issues when it fails to work correctly.

Things to Consider:

  • Use common components to provide tracing support.
  • Capture and report sufficient information about errors and state changes in order to enable accurate monitoring, debugging, and management.


Testability is a measure of how well system or components allow you to create test criteria and execute tests to determine if the criteria are met. Testability allows faults in a system to be isolated in a timely and effective manner.

Things to Consider:

  • Design systems to be modular to support testing.
  • Provide instrumentation or implement probes for testing, mechanisms to debug output, and ways to specify inputs easily.
  • Start testing early during the development life cycle. Use mock objects during testing, and construct simple, structured test solutions.
  • Automate user interaction tests, and how you can maximize test and code coverage.
  • Input and output inconsistencies; for the same input, the output is not the same and the output does not fully cover the output domain even when all known variations of input are provided. of test cases.

User Experience / Usability

The application interfaces must be designed with the user and consumer in mind so that they are intuitive to use, can be localized and globalized, provide access for disabled users, and provide a good overall user experience.

Things to Consider:

  • Too much interaction (an excessive number of clicks) required for a task.
  • Ensure  you design the screen and input flows and user interaction patterns to maximize ease of use.
  • Incorrect flow of steps in multistep interfaces.
  • Data elements and controls are poorly grouped. Choose appropriate control types and layout controls and content using the accepted UI design patterns.
  • Use asynchronous techniques for background tasks, and tasks such as populating controls or performing long-running tasks.

Source : Application Architecture Guidelines

Factual – A Context based API



If you are looking for an API which provides context related data on the following go and have a look at Factual API.

1. Healthcare Providers Data (Currently only in US)

2. Restaurants data including cuisine, pricing, rating

3. Hotels data including price, guest rating

4. World geographies data

The API’s are available in NuGet. To get started you need to get a Key from here.

To see the list of tools and documents check here. For Pricing check here.

After you get the key you can use any of the following tools to access the API. There is a C# version of API with examples as well available now.

Next Post


Originally posted on Jega's Blog:


Refer to this post for ebooks of ASP.NET, Windows Azure & SQL Server from Microsoft.

Moving to Microsoft Visual Studio 2010
Programming Windows 8 Apps
Programming Windows Phone 7
Programming Windows Phone 7 (Special Excerpt 2)
Office 365 – Connect and Collaborate virtually anywhere, anytime
Microsoft Office 2010 First Look
Security and Privacy for Microsoft Office 2010 Users
Getting started with
Microsoft Office 2010 – For IT Professionals
Planning guide for Microsoft Office 2010 – For IT professionals
Deployment guide for Microsoft Office 2010 – For IT professionals
Operations guide for Microsoft Office 2010 – For IT professionals
Technical reference for Microsoft Office 2010 – For IT professionals
Technical reference for Microsoft Office 2010 – For IT professionals
Understanding Microsoft Virtualization R2 Solutions
Introducing Windows Server 2012
Introducing Microsoft SQL Server 2012
Introducing Microsoft SQL Server 2008 R2

Configure Kerberos Authentication for SharePoint 2010 Products

Business continuity management…

View original 322 more words

Design and Architecture Checklist – .NET Performance and Scalability

I am following up with Design checklist for ADO .NET Performance with this Design & architecture for .NET Applications performance.

Data Structures and Algorithms

  • Ensure your design uses appropriate data structures.
  • Use custom collections only where absolutely necessary.
  • Extend the IEnumerable interface for your custom collections.

Data Access

  • Pass data across the layers by using the most appropriate data format.
  • Carefully consider the performance implications.
  • Use stored procedures with the Parameters collection for data access.
  • Only process the data that is required.
  • Where appropriate, provide data paging solutions for large result sets.
  • Use Enterprise Services declarative transactions for transactions that span multiple resource managers or where you need to flow transaction context across components.
  • If you manipulate binary large objects (BLOBs), use appropriate chunking techniques, and do not repeatedly move the same BLOB.
  • Consolidate repeated data access code into helper classes.

Coupling and Cohesion

  • Ensure your design is loosely coupled.
  • Exhibit appropriate degrees of cohesion in your design and group together logically related entities, such as classes and methods.
  • Restrict use of late binding and only use late binding where it is necessary and appropriate.


  • Interfaces do not enforce chatty communication.
  • Ensure your application only makes remote calls where necessary.
  • Optimize remote data exchange.
  • Choose appropriate secure communication mechanisms.
  • Use message queues to decouple component parts of your system.
  • Mitigate the impact of long-running calls by using message queues, “fire-and forget” approaches, and asynchronous method calls.
  • Do not use processes where application domains are more appropriate.


  • Do not create threads on a per-request basis, use CLR Thread pool instead.
  • Only types that need to be thread-safe are made thread-safe.
  • Carefully consider lock granularity..
  • Ensure your application acquires shared resources and locks late and releases them early to reduce contention.
  • Choose appropriate synchronization primitives.
  • Choose an appropriate transaction isolation level.
  • Ensure your application uses asynchronous execution for I/O bound tasks and not for CPU bound tasks.

Resource Management

  • Ensure your design supports and makes effective use of pooling.
  • Ensure your application acquires resources late and releases them early.


  • Use caching for data that is expensive to retrieve, compute, and render.
  • Cache appropriate data such as relatively static Web pages, specific items of output data, stored procedure parameters, and query results.
  • Do not use caching for data that is too volatile.
  • Select an appropriate cache location.
  • Select an appropriate cache expiration policy.

State Management

  • Your design favors stateless components. Or, you considered the negative impact on scalability if you decided to use stateful components.
  • If you use Microsoft® .NET Framework remoting and need to support load balancing, you use single call server-activated objects (SAO).
  • If you use Web services, you also use a message-based stateless programming model.
  • If you use Enterprise Services, also use stateless components to facilitate object pooling.
  • Objects that you want to store in state stores support serialization.
  • Consider the performance impact of view state.
  • Use statistics relating to the number of concurrent sessions and average session data per user to help choose an appropriate session state store.

Exception Handling   

  • Use well-defined exception handling boundaries.
  • Structured exception handling is the preferred error handling mechanism. Do not rely on error codes.
  • Only catch exceptions for a specific reason and when it is required.

Class Design Considerations

  • Classes own the data that they act upon.
  • Do not use explicit interfaces unnecessarily. Use explicit interfaces for versioning and for polymorphism where you have common functionality across multiple classes.
  • Classes do not contain virtual methods when they are not needed.
  • Prefer overloaded methods to methods that take variable

Deployment and Infrastructure

  • Locate components that interact frequently within the same boundary or as close to each other as possible.
  • Take infrastructure restrictions into account in your design.
  • Consider network bandwidth restrictions.
  • Identify resource restrictions.
  • Ensure your design does not prevent you from scaling up.
  • Ensure your design does not prevent you from scaling out and it uses logical layers.

Related articles

Source : Scaling .NET Applications

Programming interview questions with answers – ASP.NET, jQuery, JAVA, SQL, LINQ, Entity Framework and Regular Expressions



  1. Introduction to technical interviewing
  2. Technical Interview Process – 30,000 feet overview
  3. So, what can be asked in a programming interview?
  4. Beyond the Code

Beginners programming questions

  1. Simple coding questions–Part 1
  2. How to find if a number is a Palindrome?
  3. Linked lists demystified
  4. Recursion–concepts and code
  5. Linked Lists – Sorting, Searching, Finding Maximum and Minimum
  6. Reverse a Linked List
  7. Searching algorithms–Linear search
  8. Binary Search
  9. String manipulation can be fun
  10. String pattern matching
  11. String functions galore
  12. Pass by value versus reference in C#
  13. How to find if a number is perfect square

Advanced programming questions

  1. Lost in a Forest of Trees
  2. The Ins and Outs of a Binary Search Tree
  3. Simple Patterns: Singleton Pattern
  4. Simple Patterns: Repository Pattern
  5. Simple Patterns: Factory Pattern
  6. Implement a basic Stack using linked List
  7. Implement a Queue data structure using a linked list
  8. Operator overloading and pairing rules in C#
  9. LINQ Query, Selection, Partial Selections and Aggregations
  10. Explain System.IO and System.IO.Compression namespaces with an example
  11. Explain C# yield keyword with an example
  12. How to store user passwords using variable length random salt bytes with secure SHA512 cryptographic hashing functions


  1. How to redirect user to another page using ASP.NET
  2. Return different HTTP response codes from Response…
  3. Tracing page execution in ASP.NET
  4. ASP.NET page validation controls
  5. ASP.NET 4 site navigation using sitemaps
  6. How do you serialize an object to and from XML
  7. Manage state across entire application in ASP.NET
  8. How to monitor file system changes using FileSystemWatcher in C#
  9. ASP.NET @ Page directive
  10. How to add HTML Server Controls to a Web Page Using ASP.NET
  11. ASP.NET AJAX using UpdatePanel control
  12. ASP.NET Session modes explained
  13. Explain ASP.NET data binding using DataSets and DataSourceControls
  14. ASP.NET HttpModule explained
  15. ASP.NET HttpHandlers


  1. jQuery AJAX functions part 1–the load() method
  2. jQuery AJAX functions part 2–get(), post(), getScript() and getJSON()
  3. jQuery AJAX functions part 3–ajax()
  4. Differentiate between alert(), prompt() and confirm() methods
  5. jQuery fadeIn, fadeOut and fadeTo effects
  6. jQuery Selectors reviewed
  7. jQuery to block paste in a textbox
  8. jQuery to create default text for a textbox
  9. jQuery to select/deselect all items in a CheckBoxList
  10. jQuery to show big image on hover


  1. SQL Select Where Interview Questions
  2. SQL GROUP BY and HAVING clauses
  3. SQL CASE statement examples
  4. SQL IF-ELSE and WHILE examples


  1. LINQ – Group, Sort and Count Words in a sentence by length
  2. LINQ interview questions
  3. LINQ SKIP and TAKE interview questions
  4. LINQ JOIN interview questions


  1. Basic JAVA interview questions
  2. Explain JAVA ConcurrentModificationException and solutions to fix it
  3. JAVA serialization interview question
  4. JAVA equals() versus == operator

Entity Framework

  1. Entity Framework interview questions
  2. Entity Framework and eager loading of related entities interview questions
  3. Entity Framework and lazy loading interview questions
  4. Entity Framework transaction scope examples

Regular Expressions

  1. Regular expressions interview questions–Part 1
  2. Regular expressions interview questions–Part 2
  3. Regular expressions – groups and alternations (Part 3)

Source :

Programming interview questions with answers covering ASP.NET, jQuery, JAVA, SQL, LINQ, Entity Framework and Regular Expressions – Nikhil Singhal’s Blog – Site Home – MSDN Blogs.

Windows 8 Contracts for Sharing Data



Windows 8 supports sharing the data from one application to another with in built support through contracts.

Follow Data type packages can be passed from one application to another :

1. URI

2. Plain Text

3. Formatted Text


5. Images

6. Files

7. Custom Data Formats

This blog has a getting started sample of contracts in action.

Windows 8 and the future of XAML: Part 5: More contracts in WinRT/Windows 8.


Design Checklist for Scaling .NET Applications – ADO.NET



This is a handy design checklist to check when you are writing a ADO.NET implementation.


Things to check for when using Connection Object

  • Pool connections.
  • Explicitly close connections.
  • Specify CommandBehavior.CloseConnection if you are using DataReader
  • For single operations of Fill/Update do not open a connection explicitly
  • Avoid checking the State property of OleDbConnection.

Things to check for when using Parameter Object

  • Use Parameters collections when calling stored procedures/building SQL Statements.
  • Use the Parameters collection when you build SQL statements.
  • Explicitly create stored procedure parameters.
  • Specify parameter types.
  • Cache stored procedure SqlParameter objects.

Things to check for when using DataReader Object

  • Always Close DataReader objects.
  • Use CommandBehavior.CloseConnection to close connections.
  • Always Cancel pending data.
  • Use CommandBehavior.SequentialAccess with ExecuteReader.
  • Use GetOrdinal when using an index-based lookup.

Things to check for when using DataSets

  • Reduce serialization.
  • Use primary keys and Rows.Find for indexed searching.
  • Use a DataView for repetitive non-primary key searches.
  • Use optimistic concurrency model for datasets.

Things to check for in Exception Handling

  • Always check the ConnectionState property when handling exceptions.
  • Always use try/finally to clean up resources
  • Do not use generic exceptions. Use specific handlers to catch specific exceptions.


  • Use SQL transactions for server controlled-transactions on a single data storage
  • Use ADO.NET transactions for client-controlled transactions on a single data storage.
  • Use Distributed Transaction Coordinators (DTC) for transactions that span multiple data storage’s,
  • Keep transactions as short as possible.
  • Use the appropriate isolation level.
  • Avoid code that can lead to deadlock.


  • Avoid unnecessary type conversions


Source : Scaling .NET Applications

Reversing a Double Linked List




Double linked list is a linked list which has connectors in both directions.

Quick way to reverse a double linked list is to reverse the connectors in the linked list.

This is the code in C# which reverses the data content in a double linked list.

using System;
using System.Text;

namespace DoubleLinkedList
    public class DoubleLink
        public string Title { get; set; }
        public DoubleLink PreviousLink { get; set; }
        public DoubleLink NextLink { get; set; }

        public DoubleLink(string title)
            Title = title;

        public override string ToString()
            return Title;

    public class DoubleLinkedList
        private DoubleLink _first;
        public DoubleLinkedList()
            _first = null;
        public DoubleLink Insert(string title)
    // Creates a link, sets its link to the first item and then makes this the first item in the list.
            DoubleLink link = new DoubleLink(title);
            link.NextLink = _first;

            if (_first != null)
                _first.PreviousLink = link;

            _first = link;

            return link;

        public DoubleLink Delete()
    // Gets the first item, and sets it to be the one it is linked to
            DoubleLink temp = _first;

            if (_first != null)
                _first = _first.NextLink;

                if (_first != null)
                    _first.PreviousLink = null;

            return temp;

        public string PrintList()
            DoubleLink currentLink = _first;

            StringBuilder builder = new StringBuilder();

            while (currentLink != null)
                currentLink = currentLink.NextLink;

            return builder.ToString();

        public void InsertAfter(DoubleLink link, string title)
            if (link == null || string.IsNullOrEmpty(title))

            DoubleLink newLink = new DoubleLink(title);
            newLink.PreviousLink = link;
            if (link.NextLink != null)
                link.NextLink.PreviousLink = newLink;
                newLink.NextLink = link.NextLink;
                link.NextLink = newLink;
        public void Reverse()
            while (_first != null)
               //Swap the links
                DoubleLink dl = _first.PreviousLink;
                _first.PreviousLink = _first.NextLink;
                _first.NextLink = dl;                if (_first.PreviousLink != null)
                    _first = _first.PreviousLink;  
                    // Move to the next node in original list


Templating the Project Solution Structure – Templify


If you are looking for a standard Solution template for your project which needs to be standardized across your team then Templify is one of the option which you can look upon.

If you standardize this way then any solution developer creates will have the same folder structure with your referenced assemblies, build process templates, frameworks and tools.

All this you can do this inside your Windows Explorer.

Steps to Templating your solution :

1. Install Templify. You can get from the github.

2. Create your Template solution with empty projects, references, build etc.. (You define what goes in here).

3. Right click on the folder which contains your template solution and select the option “Templify this”.


This will launch the Templify UI, which will ask you to fill in the following details:


In the token field you should enter the repeating token (the top namespace identifier)  that will be replaced with a new value when the package will be deployed.

If you want to exclude files from the template folder you can do so by clicking on Manage Exclusions.

Once you entered all the values and selected the exclusions(If needed) then select Templify.

When the solution has been templified and turned into a package a toast will appear notifying you that the process has been successful. Packages are created at the following location:


Packages are created using the wonderful 7Zip format but with an extension changed to .pkg. If you want to peek inside a package simply open it with 7Zip.

4. Now pick any folder you want to create new solution template from this template.

5. Right click on the folder and select ‘Templify Here”.

6. Pick the Template and name your instance.

7. Select Deploy Template

Now you will have a customized version of your template which contains the elements you have defined your template ready for use and you don’t need worry about different solution structure inside the team.


Designing for Scalability – Scalability Rules


, ,


Rules for Designing the System for Scalability

  • Don’t over engineer. Keep the design simple.
  • Design scaling into the design.
    • Design for 20x capacity
    • Implement for 3x,
    • Deploy for 1.5x
  • Simplify the scope - Use the 80-20% principle. Which of the 20% feature bring 80% of the benefit?
  • Simplify the Design - Use existing solutions (In house, 3rd party).
  • Simplify the Implementation
    • Split Data & Services effectively. Use Nouns and verbs approach to identify data & services.
    • Have a good logging framework – Use right monitoring tools to actively monitor the log and assign resources to look into the logs.
    • Don’t duplicate the work – Example: Don’t read the data which was written in the storage for the purpose of validation.
    • Remember this analogy – Measure twice and cut only once.
    • Use Caching aggressively and effectively.
    • Make use of object caches. Implement the cache in its own tier (Example : Application Server).
  • Design to Scale out not just Scale up.
  • Don’t rely on Testing team to increase quality. Quality have to inbuilt into the system.
  • Design for Rollback
    • Don’t accept that the application is too complex or that you release code too often as excuses that you can’t roll back. No sane pilot would take off in an airplane without the ability to land, and no sane engineer would roll code that they could not pull back off in an emergency.
  • Eliminate Single points of Failure.
  • Reduce the number of components that are connected in a series.
  • Create a framework to disable/enable features.
  • Develop shared libraries to lower the cost of future implementation.
  • Develop stateless implementations unless warranted for business reasons.
  • Avoid using Multiphase commits in protocol/storage/transactions.
  • Always use asynchronous communication to ensure each service and its tier is independent as possible.
  • Remove Business logic from Transaction processing.
    • o    Keep application logic separate from database. Keep database focused on transactions.
  • Build hooks into the system to actively monitor it.

 Source : Scalability Rules


Programmer Competency Matrix


, , ,


If you are looking to assess skills required in software engineering then check this out.

The list contains categories from Computer Science, Software Engineering, Programming, Experience & Knowledge.

Computer Science
  2n(Level 0) n2(Level 1) n (Level 2) log(n) (Level 3) Comments
data structures Doesn’t know the difference between Array and Linked List Able to explain and use Arrays, Linked Lists, Dictionaries etc in practical programming tasks Knows space and time tradeoffs of the basic data structures, Arrays vs Linked Lists, Able to explain how hash tables can be implemented and can handle collisions, Priority queues and ways to implement them etc. Knowledge of advanced data structures like B-trees, binomial and Fibonacci heaps, AVL/Red Black trees, Splay Trees, Skip Lists, tries etc.  
algorithms Unable to find the average of numbers in an array (It’s hard to believe but I’ve interviewed such candidates) Basic sorting, searching and data structure traversal and retrieval algorithms Tree, Graph, simple greedy and divide and conquer algorithms, is able to understand the relevance of the levels of this matrix. Able to recognize and code dynamic programming solutions, good knowledge of graph algorithms, good knowledge of numerical computation algorithms, able to identify NP problems etc. Working with someone who has a good top coder ranking would be an unbelievable piece of luck!
systems programming Doesn’t know what a compiler, linker or interpreter is Basic understanding of compilers, linker and interpreters. Understands what assembly code is and how things work at the hardware level. Some knowledge of virtual memory and paging. Understands kernel mode vs. user mode, multi-threading, synchronization primitives and how they’re implemented, able to read assembly code. Understands how networks work, understanding of network protocols and socket level programming. Understands the entire programming stack, hardware (CPU + Memory + Cache + Interrupts + microcode), binary code, assembly, static and dynamic linking, compilation, interpretation, JIT compilation, garbage collection, heap, stack, memory addressing…  
Software Engineering
  2n(Level 0) n2(Level 1) n (Level 2) log(n) (Level 3) Comments
source code version control Folder backups by date VSS and beginning CVS/SVN user Proficient in using CVS and SVN features. Knows how to branch and merge, use patches setup repository properties etc. Knowledge of distributed VCS systems. Has tried out Bzr/Mercurial/Darcs/Git  
build automation Only knows how to build from IDE Knows how to build the system from the command line Can setup a script to build the basic system Can setup a script to build the system and also documentation, installers, generate release notes and tag the code in source control  
automated testing Thinks that all testing is the job of the tester Has written automated unit tests and comes up with good unit test cases for the code that is being written Has written code in TDD manner Understands and is able to setup automated functional, load/performance and UI tests  
  2n(Level 0) n2(Level 1) n (Level 2) log(n) (Level 3) Comments
problem decomposition Only straight line code with copy paste for reuse Able to break up problem into multiple functions Able to come up with reusable functions/objects that solve the overall problem Use of appropriate data structures and algorithms and comes up with generic/object-oriented code that encapsulate aspects of the problem that are subject to change.  
systems decomposition Not able to think above the level of a single file/class Able to break up problem space and design solution as long as it is within the same platform/technology Able to design systems that span multiple technologies/platforms. Able to visualize and design complex systems with multiple product lines and integrations with external systems. Also should be able to design operations support systems like monitoring, reporting, fail overs etc.  
communication Cannot express thoughts/ideas to peers. Poor spelling and grammar. Peers can understand what is being said. Good spelling and grammar. Is able to effectively communicate with peers Able to understand and communicate thoughts/design/ideas/specs in a unambiguous manner and adjusts communication as per the context This is an often under rated but very critical criteria for judging a programmer. With the increase in outsourcing of programming tasks to places where English is not the native tongue this issue has become more prominent. I know of several projects that failed because the programmers could not understand what the intent of the communication was.
code organization within a file no evidence of organization within a file Methods are grouped logically or by accessibility Code is grouped into regions and well commented with references to other source files File has license header, summary, well commented, consistent white space usage. The file should look beautiful.  
code organization across files No thought given to organizing code across files Related files are grouped into a folder Each physical file has a unique purpose, for e.g. one class definition, one feature implementation etc. Code organization at a physical level closely matches design and looking at file names and folder distribution provides insights into design  
source tree organization Everything in one folder Basic separation of code into logical folders. No circular dependencies, binaries, libs, docs, builds, third-party code all organized into appropriate folders Physical layout of source tree matches logical hierarchy and organization. The directory names and organization provide insights into the design of the system. The difference between this and the previous item is in the scale of organization, source tree organization relates to the entire set of artifacts that define the system.
code readability Mono-syllable names Good names for files, variables classes, methods etc. No long functions, comments explaining unusual code, bug fixes, code assumptions Code assumptions are verified using asserts, code flows naturally – no deep nesting of conditionals or methods  
defensive coding Doesn’t understand the concept Checks all arguments and asserts critical assumptions in code Makes sure to check return values and check for exceptions around code that can fail. Has his own library to help with defensive coding, writes unit tests that simulate faults  
error handling Only codes the happy case Basic error handling around code that can throw exceptions/generate errors Ensures that error/exceptions leave program in good state, resources, connections and memory is all cleaned up properly Codes to detect possible exception before, maintain consistent exception handling strategy in all layers of code, come up with guidelines on exception handling for entire system.  
IDE Mostly uses IDE for text editing Knows their way around the interface, able to effectively use the IDE using menus. Knows keyboard shortcuts for most used operations. Has written custom macros  
API Needs to look up the documentation frequently Has the most frequently used APIs in memory Vast and In-depth knowledge of the API Has written libraries that sit on top of the API to simplify frequently used tasks and to fill in gaps in the API E.g. of API can be Java library, .net framework or the custom API for the application
frameworks Has not used any framework outside of the core platform Has heard about but not used the popular frameworks available for the platform. Has used more than one framework in a professional capacity and is well-versed with the idioms of the frameworks. Author of framework  
requirements Takes the given requirements and codes to spec Come up with questions regarding missed cases in the spec Understand complete picture and come up with entire areas that need to be spaced Able to suggest better alternatives and flows to given requirements based on experience  
scripting No knowledge of scripting tools Batch files/shell scripts Perl/Python/Ruby/VBScript/PowerShell Has written and published reusable code  
database Thinks that Excel is a database Knows basic database concepts, normalization, ACID, transactions and can write simple selects Able to design good and normalized database schemas keeping in mind the queries that’ll have to be run, proficient in use of views, stored procedures, triggers and user defined types. Knows difference between clustered and non-clustered indexes. Proficient in use of ORM tools. Can do basic database administration, performance optimization, index optimization, write advanced select queries, able to replace cursor usage with relational sql, understands how data is stored internally, understands how indexes are stored internally, understands how databases can be mirrored, replicated etc. Understands how the two phase commit works.  
  2n(Level 0) n2(Level 1) n (Level 2) log(n) (Level 3) Comments
languages with professional experience Imperative or Object Oriented Imperative, Object-Oriented and declarative (SQL), added bonus if they understand static vs dynamic typing, weak vs strong typing and static inferred types Functional, added bonus if they understand lazy evaluation, currying, continuations Concurrent (Erlang, Oz) and Logic (Prolog)  
platforms with professional experience 1 2-3 4-5 6+  
years of professional experience 1 2-5 6-9 10+  
domain knowledge No knowledge of the domain Has worked on at least one product in the domain. Has worked on multiple products in the same domain. Domain expert. Has designed and implemented several products/solutions in the domain. Well versed with standard terms, protocols used in the domain.  
  2n(Level 0) n2(Level 1) n (Level 2) log(n) (Level 3) Comments
tool knowledge Limited to primary IDE (VS.Net, Eclipse etc.) Knows about some alternatives to popular and standard tools. Good knowledge of editors, debuggers, IDEs, open source alternatives etc. etc. For e.g. someone who knows most of the tools from Scott Hanselman’s power tools list. Has used ORM tools. Has actually written tools and scripts, added bonus if they’ve been published.  
languages exposed to Imperative or Object Oriented Imperative, Object-Oriented and declarative (SQL), added bonus if they understand static vs dynamic typing, weak vs strong typing and static inferred types Functional, added bonus if they understand lazy evaluation, currying, continuations Concurrent (Erlang, Oz) and Logic (Prolog)  
codebase knowledge Has never looked at the codebase Basic knowledge of the code layout and how to build the system Good working knowledge of code base, has implemented several bug fixes and maybe some small features. Has implemented multiple big features in the codebase and can easily visualize the changes required for most features or bug fixes.  
knowledge of upcoming technologies Has not heard of the upcoming technologies Has heard of upcoming technologies in the field Has downloaded the alpha preview/CTP/beta and read some articles/manuals Has played with the previews and has actually built something with it and as a bonus shared that with everyone else  
platform internals Zero knowledge of platform internals Has basic knowledge of how the platform works internally Deep knowledge of platform internals and can visualize how the platform takes the program and converts it into executable code. Has written tools to enhance or provide information on platform internals. For e.g. disassemblers, decompilers, debuggers etc.  
books Unleashed series, 21 days series, 24 hour series, dummies series… Code Complete, Don’t Make me Think, Mastering Regular Expressions Design Patterns, Peopleware, Programming Pearls, Algorithm Design Manual, Pragmatic Programmer, Mythical Man month Structure and Interpretation of Computer Programs, Concepts Techniques, Models of Computer Programming, Art of Computer Programming, Database systems , by C. J Date, Thinking Forth, Little Schemer  
blogs Has heard of them but never got the time. Reads tech/programming/software engineering blogs and listens to podcasts regularly. Maintains a link blog with some collection of useful articles and tools that he/she has collected Maintains a blog in which personal insights and thoughts on programming are shared  

Excel version–self-evaluation-excel-sheet/free-documents/



Which Data structure to choose ? – Data Structures selection and performance comparison


, ,

Data structures are important and it provides a easy and efficient way to organize the data in any function/program.

Choosing the correct data structure is important and the performance of the program is directly proportional to the data structure used.

Proper analysis needs to be done to pick the correct data structure.

Example : One data structure might be good in accessing the data in a order but might not be good in accessing a random data.

Important key factor/question one need to ask in deciding the deciding the data structure is “How the data is going to be used ?”

Big O is a notation which gives a nice representation of how many steps it will take to complete a task of fetching the data or the algorithm used to fetch the data.

If there is a function say

int GetData(int x) { return 2+x;}

this function has one step to complete and it is represented in Big O as O(1).

Now if the function is like this :

int GetData(int x)


int result = 1;

for(int i=0,i


result =result*i;


return result;


In the above function the result is determined by the line result = result*i and it is inside a loop.

Since this loop will be executed n number of times in Big O this will represented as O(n) and this is called Linear time.

Following table shows the speed comparison of each data structure represented in Big O Notation.

 Data Structure

Adding data to end

Removing data  
from end

Inserting data in the middle

data from the middle

Random Data Access

In-order  Data

Searching for specific data element










Most efficient use of memory; use in cases where data size is fixed.


best case O(1);

worst case O(n)







Implementation is optimized
for speed. In many cases, List
will be the best choice.


best case O(1);

worst case O(n)







List is a better choice, unless
publicly exposed as API.









Many operations are fast,
but watch out for cache


best case O(1);

worst case O(n)







Shouldn’t be selected for
performance reasons, but
algorithmic ones.


best case O(1);

worst case O(n)







Shouldn’t be selected for
performance reasons, but
algorithmic ones.


best case O(1);

worst case O(n)


best case O(1); worst case O(n)





Although in-order access time
is constant time, it is usually slower than other structures due to the over-head of looking up the key.

Source : MSDN

Selecting a Collection Class – An MSDN article with rules of thumb for data structure selection

Hands on labs – Windows 8, Silverlight, PRISM, Enterprise library, Data Access Frameworks.


, , , , ,

I have compiled here a list of Hands on labs of Windows 8, PRISM, Entity Framework, Enterprise Library.

Windows 8 Applications - CSharp & Javascript -  A series of 8 hands on lab modules that guide one through the development of a Windows 8 Store App.


PRISM 4.1 - Prism provides guidance designed to help you more easily design and build rich, flexible, and easy to maintain Windows Presentation Foundation (WPF) desktop applications and Silverlight Rich Internet Applications (RIAs) and Windows Phone 7.1 (“Mango”) applications

Data Access Frameworks – (EF/ADO.NET)

Microsoft Enterprise library 5.0  - Covers Caching, Configuration Sources, Cryptography, Data Access, Exception Handling, Interception, Logging, Security, Validation, and Unity.


Get every new post delivered to your Inbox.