Archive

Archive for the ‘ASP.NET’ Category

Using INT or GUID for Primary Keys? Or COMB GUID?

January 21, 2010 3 comments

Today I read an interesting article by Jimmy Nilsson (the author of .Net Enterprise Design) about using auto-generated primary keys in SQL Server. Especially for Surrogate Keys.

Of course, most of our decisions would be to use INT (or BIGINT) as data type and set IDENTITY to true. There is another solution: using GUID. [NEWID in SQL Server].

When a comparison is done between using INT and GUID as primary key, we can list out few important differences:

Pros of using GUID

  1. GUID will be unique through out the database; while INT is not
  2. @@IDENTITY can be a problem while doing INSERT through TRIGGERS. And using @@IDENTITY to get the identity for the recently added row in the table brings the created identity for the current connection.[This could be solved using SCOPE_IDENTITY (see here for an excellent explanation on this!)]
  3. GUID can be used to create primary keys before inserting the value to the database
  4. Integers are not big enough for most of the scenarios; even though you could start from smallest negative value. Anyway BIGINT can be a solution here.
  5. Using INT could be a real night mare when doing manual merge of tables.

Cons of using GUID

  1. 1. In theory GUID presents a risk of getting duplicate GUIDs; but in practice it is not. In the recent windows version (from windows 2000) the algorithm to generate GUIDs doesn’t use the MAC address of the network cars. Instead it is just a random value.
  2. GUID is 4 times larger in size.
  3. There are portability problems, not all the database have GUID as a data type.
  4. Huge overhead; 4 times larger than INT.
    Evolution of COMB GUID

So apparently overhead is the main problem here. When Jimmy Nilsson did real  inserts using GUID as primary key he found out that time taken for inserts with GUID is 30 times greater than inserts with INT. That happened for 2 reasons

1. The generated GUIDs lacked the order; they were random. As you see in the below table only the 4 is common.

C87FC84A-EE47-47EE-842C-29E969AC5131
2A734AE4-E0EF-4D77-9F84-51A8365AC5A0
70E2E8DE-500E-4630-B3CB-166131D35C21
15ED815C-921C-4011-8667-7158982951EA
56B3BF2D-BDB0-4AFE-A26B-C8F59C4B5103

2. SQL insert statement makes the indexes to be reordered and this takes a lot of time. The new ordering for indexes depended on the last bytes

Therefore Jimmy Nilsson arrived at a new algorithm and his new GUID is called as COMB GUIDs.

Jeffery Palermo in his book ASP.NET MVC in Action uses this COMB GUID for his sample code to explain NHibernate. I am using this COMB GUID for my pet project.

Other Resources:

  1. GUIDs as PRIMARY KEYs and/or the clustering key
  2. NHibernate POID Generators revealed : COMB GUID does not cause database fragmentation
  3. INT vs Unique-Identifier for ID field in database
  4. GUIDs are one of the leading causes of index fragmentation
  5. Top tips for effective database managements

JQuery Error : $ is undefined

November 17, 2009 7 comments

When ever you get a JQuery ‘$ is undefined’ error, then the problem must be because reference to the jquery file is not correct and it is not loaded. Try to resolve the path of the jquery script file using Resolve URL.

<script type="text/javascript" src='<%= ResolveUrl("~/Scripts/jquery-1.3.2.js") %>’></script>

Lets say your jquery script file “jquery-1.3.2.js” is located in /Scripts under root directory, then you will have to resolve your url as said previously.

This is not a problem specific to JQuery files but is common to all master-content page. You have a master page and a content page. In the master page you have the reference to a javascript file (or css) using “~”. Unless all these files fall in the same folder you would not have any problem. The problem occurs only when the files are in different folders.

Converting ASP.NET Web Site to Web App

November 6, 2009 Leave a comment

There is a common mistake which almost most of us made when we  created a new web site with Visual Studio 2005. The earlier version of Visual Studio 2005 does not include a template for web application. In other words, it was only possible to create website.

So why do you have to convert from website to web app first of all? Well there are quite a few reasons to list out:

  Web Site Web App
Compilation of Markup Dynamic Dynamic
Compilation of code behind dynamic by default; can pre -compile the site using 2 modes – batch mode (one assembly per folder) and fixed-names (one assembly for each page or user control; this may result in increased memory usage) Precompiled; All code is compiled in to single assembly
Scope Only code in App_Code is available to all classes; namespaces are not created by default Since it is precompiled all page classes are in same assembly and are visible to all; namespace is created by default
File Structure Just aggregates files in a directory so based on file system; project file list and other assembly list are present in web.config (which violates SoC) has a neat project file which helps to have information of files and assemblies, helps in controlled build and deployment

After reading the above difference website option may look evil; but that’s not the case. There are cases when website may come in to rescue. In fact we have been using web site for our application for a long time. And deployment was not a problem, we used NANT to compile the application (batch-mode) and used INSTALLSHIELD to deploy the application.

So when to use website or webapp project? There is an excellent article from MSDN:

 

Task Web application projects Web site projects
Need to migrate large Visual Studio .NET 2003 applications X  
Prefer single-page code model to code-behind model   X
Prefer dynamic compilation and working on pages without building entire site on each page view (that is, save file and then simply refresh the page in the browser).   X
Need to control names of output assemblies X  
Need to generate one assembly for each page   X
Need stand-alone classes to reference page and user control classes X  
Need to build a Web application using multiple Web projects X  
Need to add pre-build and post-build steps during compilation X  
Want to open and edit any directory as a Web project without creating a project file   X

But after an over all comparison, Web Application looks more structured and gives us more control over the project.

How to convert a web site to web application?

ScotGu has given an excellent step-by-step approach to convert a web site to web application. (In fact the Microsoft consultant who came to audit our project also gave the same printout as guidance). This is an excellent resource to start with.

While I did the conversion I took notice of some points that are worth mentioning in addition to Scottgu’s list.

Pre-Requisites:

  1. Visual Studio 2005 does not have an option for web application project. The web application project template was later added to the visual studio in Visual Studio 2005 SP1.Please read here for What is new in Visual Studio 2005 SP1? Web application projects is one among them.
  2. If you are installing VS 2005 SP1 on Windows 2003 server you may get a weird error "The installation source for this product is not available". You must install a hotfix to fix this.
  3. So install the hot fix (point 2), restart the machine and then install VS 2005 SP1.
    Also see ScottGu’s suggestions on installing the service pack.

Steps in conversion:

  1. Create a web application project.
  2. Add reference to all of your dlls.
  3. Copy the files to the folder except web.config file
  4. Remember there is no App_Code in web application. So any classes in the app_code will not be visible to other classes in the project. This will break the build. To avoid this as a quick and effective fix, add a namespace to your classes in App_Code. And replace this class name with the fully qualified class name (with the newly added namespace) through out the project. (Of course not in the original class file in app_code). Renamed the app_code folder to something like Shared_Classes or something; this would avoid confusion.
  5. Change the Build Action to <compile> for all the classes in App_Code.
  6. Convert to Web Application.
  7. image
  8. When the convert to web application is being done the conversion may fail for some aspx files that use user controls that reside in the same directory and the same user control is also registered in the web.config file. Actually the creation of designer file may fail because of this error: tag has already been registered. To avoid this: register the user control in the problematic ascx page but choose a different TagPrefix (different from the one you have already registered in web.config file). For example:

These are few additional things I noticed while converting the project from web application to web site. Hope this helps!

Moving ASP.NET web application from 32 bit to 64 bit

October 26, 2009 1 comment

Before we jump in to the details, we need to know few things to understand some basics.

Managed module is a standard 32 bit Microsoft Windows Portable Executable (PE32) file or standard 64 bit Microsoft Windows Portable Executable file (PE32+) that requires CLR to execute.

Parts of managed module:

PE32 or PE32+ header

Contains information about
1.    format of the file (PE32 or PE32+)
2.    type of the file (DLL, CUI or GUI)
3.    a timestamp: the time when the file is built.
4.    Information about native CPU code (if the module contain native CPU code)
For modules that has only IL this information is not used

CLR header

This includes information about
1.    Version of the CLR required
2.    MethodDef metadata token of the managed module’s entry point
3.    Location of Metadata and size of metadata
4.    resources
5.    strong name

Metadata

Usually this part contains 2 tables
1.    information about the types and members defined in the module’s source
2.    information about the types and members referred by the module’s source.

Intermediate
Language code
Code produced by compiler during compilation. At run time CLR compiles the IL in to native CPU instructions.

 

Always keep in mind that all CLR complaint compilers produce IL code. At times this IL code is referred as managed code because it is managed by CLR.

Assembly Assembly is a logical group of one or mode modules
Manifest Manifest is a set of metadata tables that have information about list of files in the assembly, the dependencies of the files in the assembly and resource or data files associated with the files

 

Before we understand how CLR loads the managed code or assembly we need to study the difference between 32 bit and 64 bit versions of windows.

If your assembly files contain only type-safe managed code, you are writing code that should work on both 32-bit and 64-bit versions of Windows. No source code changes are required for your code to run on either version of Windows. In fact, the resulting EXE/DLL file produced by the compiler will run on 32-bit Windows as well as the x64 and IA64 versions of 64-bit Windows! In other words, the one file will run on any machine that has a version of the .NET Framework installed on it.

On extremely rare occasions, developers want to write code that works only on a specific version of Windows. Developers might do this when using unsafe code or when interoperating with unmanaged code that is targeted to a specific CPU architecture.

What is Unsafe Code?
http://msdn.microsoft.com/en-us/library/62bwd2yd(VS.80).aspx

By default Microsoft’s C# compiler produces safe code. Safe code is code that is verifiably safe. However it is possible to write unsafe code. Unsafe code is allowed to work directly with memory addresses and can manipulate bytes at these addresses. This is a powerful feature and is useful when interoperating with unmanaged code.

How to check if an assembly is type safe or not?
Microsoft supplies a utility called PEVerify.exe that analyses and reports the error if any unsafe code is used in the assembly.

image

 

To aid these developers,the C# compiler offers a /platform command-line switch. This switch allows you to specify whether the resulting assembly can run on x86 machines running 32-bit Windows versions only, x64 machines running 64-bit Windows only, or Intel Itanium machines running 64-bit Windows only. If you don’t specify a platform, the default is anycpu, which indicates that the resulting assembly can run on any version of Windows.

Depending on the platform switch, the C# compiler will emit an assembly that contains either a PE32 or PE32+ header, and the compiler will also emit the desired CPU architecture (or agnostic) into the header as well. Microsoft ships two command-line utilities, DumpBin.exe and CorFlags.exe, which you can use to examine the header information emitted in a managed module by the compiler.

How to find Platform dependency?

image

CLR Header

2.0 = .NET 1.0 or 1.1
2.5 = .NET 2.0

PE

PE header type
PE32 = 32-bit
PE32+ = 64-bit

CorFlags Different flags
ILONLY Since assembly also allowed to contain native code, to be “AnyCPU” the assembly shall contain only IL.
32BIT

1 = x86 target
0 = Any CPU target

Signed

Signed    1 = Assembly signed
0 = Assembly not signed

In our example we will have to look at three properties to find if the assembly is platform dependent or not.
ILONLY –> 1
Even the assembly has only ILCode still it can be platform dependent. PE and 32 Bit properties help to get more information.
PE & 32 Bit –> PE32 & 0

The combination of PE & 32 bit for different platforms are as follows:

  PE 32Bit
AnyCPU PE32 0
X86 PE32 1
x64 PE32(+) 0

So from the information displayed by CorFlags, our test assembly is truly “AnyCPU”

Also CorFlags can be used to forcefully change the PE headers. But personally I don’t like this because if it is compiled like that then it is done for a reason.

 

What happens during running of the executable?
1.    Windows examines the EXE file’s header to determine whether the application requires a 32 bit or 64 bit address space
2.    A file with PE32 header can run with a 32 bit or 64 bit address space
3.    A file with PE32+ header requires a 64 bit address space
4.    Windows also checks the CPU architecture information embedded inside the header to ensure that it matches the CPU type in computer.

WOW64
64 bit versions of windows offer a technology that allows 32 bit windows applications to run. This technology is called WOW64 (for windows on Windows 64).It would be more appropriate if it was named as ‘Windows 32 on Windows 64”. To make it simple, WOW64 acts as a layer and let 32 bit process to run as if they are running in 32 bit system even though in real they are running in 64 bit OS. As you see there is an extra cost here. There is no free lunch.

The even allows 32 bit applications with x86 native code in them to run on an Itanium machine, because WOW technology can emulate X86 instruction set, but with a performance cost.

How do we know if the application is running under WOW64?
In the task manager if you see *32 near to your image name then your application is running under 32 bit emulation mode using WOW64. If you want to determine it from out of process use IsWow64Process.

Also you could use Module.GetPEKind to determine the platform targeted by the module.

/platform
Switch

Resulting managed module X86 Windows X64 Windows IA64 Windows
anycpu PE32/platform agnostic Runs as a 32 bit application Runs as 64 bit application Runs as a 64 bit applications
X86 PE32/X86 Runs as a 32 bit application Runs as a WoW64 application Runs as a WoW64 application
X64 PE32+/X64 Doesn’t run Runs as a 64 bit application Doesn’t run
Itanium PE32+/Itanium Doesn’t run Doesn’t run Runs as a 64 bit application

Where to set the /platform switch in VS

image

Process of creating a Process

After Windows has examined the EXE file’s header to determine whether to create a 32-bit process, a 64-bit process, or a WoW64 process, Windows loads the x86, x64, or IA64 version of MSCorEE.dll into the process’s address space. On an x86 version of Windows, the x86 version of MSCorEE.dll can be found in the C:\Windows\System32 directory. On an x64 or IA64 version of Windows, the x86 version of MSCorEE.dll can be found in the C:\Windows\SysWow64 directory, whereas the 64-bit version (x64 or IA64) can be found in the C:\Windows\System32 directory (for backward compatibility reasons). Then, the process’ primary thread calls a method defined inside MSCorEE.dll. This method initializes the CLR, loads the EXE assembly, and then calls its entry point method (Main). At this point, the managed application is up and running.

So,

1.    If your application has only managed code then you don’t hesitate to use “Any CPU”. Best option if you are just using pure c#.

2.    If your application (or any of the third party dlls) has direct native code or have an assembly that is targeted to x86 (32) then you cannot run your application in X64 environment because when the dependent assembly (targeted to x86) could not be loaded in x64 environment (will throw bad format exception). In this case, use CorFlags tool to change the target to x64, if you are so sure that can be done!. Otherwise there is a hack.

3.    If any of your code targets specifically x86 platform then you must compile targeting the platform x86. This will run in x64 in emulated mode (WoW64) but bear in mind that you have a performance hit in WoW64.

4.    If any of your code targets specifically x64 platform (this wont occur normally until you have specific pointer sizes) then you got no choice except to compile your application targeting X64.

First Look : ASP.NET 4 Beta 2 and Ajax Preview 4.0

October 23, 2009 Leave a comment

I have just finished reading this white paper. I haven’t tried most of the things; but I wish to list some features which attracted me.

I can see extensive changes in AJAX but apart from that there are some remarkable changes that would give us more control by letting us extend them. As Dino Esposito says changes in ASP.NET 4.0 can be tagged as “More Control”.

The features I like in ASP.NET 4.0 Beta 2:

Core Services

Auto-Start web application:

A new scalability feature named auto-start that directly addresses this scenario is available when ASP.NET 4 runs on IIS 7.5 on Windows Server 2008 R2. The auto-start feature provides a controlled approach for starting up an application pool, initializing an ASP.NET application, and then accepting HTTP requests.

Permanently redirecting a page:

ASP.NET 4 adds a new RedirectPermanent helper method that makes it easy to issue HTTP 301 Moved Permanently responses rather than issuing HTTP 302 Found (Temporarily redirected) response which requires another round trip to the server.

Expanding the range of allowable URLs:

length of URL is no more limited to 260 and can customize the set of valid characters using the new requestPathInvalidChars attribute of the httpRuntime configuration element

Compress Session State:

When the compressionEnabled configuration option shown in the following example is set to true, ASP.NET will compress (and decompress) serialized session state by using the .NET Framework System.IO.Compression.GZipStream class. This is available only when out-of-process session is used.

Do you know it is possible to compress for in-proc session storage scenario also – even in ASP.NET 2.0?

Object Caching and Extensibility:

To make caching available for all applications, the .NET Framework 4 introduces a new assembly, a new namespace, some base types, and a concrete caching implementation.  The new System.Runtime.Caching.dll assembly contains a new caching API in the System.Runtime.Caching namespace.  The namespace contains two core sets of classes:
•    Abstract types that provide the foundation for building any type of custom cache implementation.
•    A concrete in-memory object cache implementation (the System.Runtime.Caching.MemoryCache class).

Extensible request validation:

The request validation feature has been made extensible so that we can use custom request-validation logic.(ASP.NET request validation searches incoming HTTP request data for strings that are commonly used in cross-site scripting (XSS) attacks)

AJAX 4

Client Template rendering:

Templates offer the most manageable way of creating UI from data.

The following example shows a typical client template that we can create using ASP.NET AJAX 4.
<ul id="myTemplate" class="sys-template"
    sys:attach="dataview"
>
     <li>
        <h3>{{ Name }}</h3>
        <div>{{ Description }}</div>
    </li>
</ul>

       

Data binding

One way live binding is what we saw in previous example {{ Description }}.

Two way live binding is useful when a text box is provided that enables users to modify the value of underlying data, as in the following example:
<input type="text" value="{binding Name}"/>

In two-way live binding, the binding works in both directions. If the target value is changed (in this case, the value in the UI), the source value is automatically updated (in this case, the underlying data item). Similarly, if the source value is changed (in this case, if the underlying data value is updated externally), the target value (the value in the UI) is updated in response. As a result, target and source are always in sync.

Observer Pattern

The observer pattern enables an object to be notified about changes that occur in another object. (The term observer pattern is often misused in JavaScript frameworks to describe event handling based on the addHandler method and similar techniques.) ASP.NET AJAX 4 implements the pattern completely. It adds observer functionality to ordinary JavaScript objects or arrays so that they raise change notifications when they are modified through the Sys.Observer interface

Client side controls

The DataView control can bind to any JavaScript object or array, or to any ASP.NET AJAX component

An example:

<ul sys:attach="dataview" class="sys-template"
    dataview:data="{{ imagesArray }}"
>
    <li>   
        <h3>{{ Name }}</h3>
        <div>{{ Description }}</div>
    </li>
</ul>

End-to-end Ajax-based data scenarios:

The AdoNetServiceProxy class enables read-write interaction with ADO.NET Data Services from JavaScript. The class enables access from JavaScript to a broad range of features of ADO.NET Data Services.

The AdoNetServiceProxy class is used by the AdoNetDataContext class in read-write scenarios that provides full support for change tracking in the browser. This enables complete end-to-end AJAX-based data scenarios.

The following example shows how to use the DataContext class.

<script type="text/javascript">
    var dataContext = new Sys.Data.DataContext();
    dataContext.set_serviceUri("../Services/imagesService.svc");
    dataContext.set_saveOperation("SaveImages");
    dataContext.initialize();
</script>

<button onclick="dataContext.saveChanges()" class="right">Save Changes</button>

<ul sys:attach="dataview" class="sys-template"
    dataview:dataprovider="{{ dataContext }}"
    dataview:query="GetImages"
>
    <li>   
        <input type="text" value="{binding Name}"/><br/>
        <input type="text" value="{binding Description}"/>
    </li>
</ul>

Web Form

View state enable/disable for individual controls:

All server controls have EnableViewState property including page. But one must remember that EnableViewState property is ignored for child controls. For example if Page has EnableViewState set to True,  its child control TextBox control will always read and write to the session state no matter what we set for enableviewstate property for that control.

But ASP.NET 4.0 will change this behavior by using a special property named ViewStateMode that accepts 3 values: enabled|disabled|inherit.

This is a good improvement.

Browser capabilities:

ASP.NET 4 includes a feature referred to as browser capabilities providers. As the name suggests, this lets us build a provider that in turn lets us to use our own code to determine browser capabilities.

Routing

ASP.NET 4 adds built-in support for using routing with Web Forms. Routing lets us configure an application to accept request URLs that do not map to physical files. Instead, we can use routing to define URLs that are meaningful to users and that can help with search-engine optimization (SEO) for our application. For example, the URL for a page that displays product categories in an existing application might look like the following example:
http://website/products.aspx?categoryid=12
By using routing, we can configure the application to accept the following URL to render the same information:
http://website/products/software

Client ID creation

The new ClientIDMode property addresses a long-standing issue in ASP.NET, namely how controls create the id attribute for elements that they render.

The new ClientIDMode property lets you specify more precisely how the client ID is generated for controls. You can set the ClientIDMode property for any control, including for the page. Possible settings are the following:
•    AutoID – This is equivalent to the algorithm for generating ClientID property values that was used in earlier versions of ASP.NET.
•    Static – This specifies that the ClientID value will be the same as the ID without concatenating the IDs of parent naming containers. This can be useful in Web user controls. Because a Web user control can be located on different pages and in different container controls, it can be difficult to write client script for controls that use the AutoID algorithm because you cannot predict what the ID values will be.
•    Predictable – This option is primarily for use in data controls that use repeating templates. It concatenates the ID properties of the control’s naming containers, but generated ClientID values do not contain strings like "ctlxxx". This setting works in conjunction with the ClientIDRowSuffix property of the control. You set the ClientIDRowSuffix property to the name of a data field, and the value of that field is used as the suffix for the generated ClientID value. Typically you would use the primary key of a data record as the ClientIDRowSuffix value.
•   Inherit – This setting is the default behavior for controls; it specifies that a control’s ID generation is the same as its parent.

Query Extender – Filtering

To make data source filtering easier, a new QueryExtender control has been added in ASP.NET 4. This control can be added to EntityDataSource or LinqDataSource controls in order to filter the data returned by these controls. Because the QueryExtender control relies on LINQ, the filter is applied on the database server before the data is sent to the page, which results in very efficient operations.

The QueryExtender control supports a variety of filter options: Search,Range,Property Expression and CustomExpression.

More updates when I really work on them. Notify me incase if I had overlooked an important feature.

Happy learning!

Best books for .Net development – My Recommendations

September 24, 2009 Leave a comment

Today my manager asked me to list some good technical .net books on which our management had planned to invest.

I always had a wish list for technical books; I could easily  arrive at a list.

I categorized the books as follows:

  1. Programming.Net (That helps core programming. Mostly on C# core and ASP.NET core)
  2. Design/Architecture/Guidelines (Design Patterns, Best Practices, Modeling Patterns)
  3. Concepts (General concepts for programming, UI design)
  4. Source control / Build & deployment

I didn’t cover books on WCF/WPF/Silver Light/RESTful services/ASP.NET MVC/Entity Framework as I don’t have enough knowledge on those books.

Programming .NET

  1. CLR via C# by Jeffery Richter
  2. Programming Microsoft Visual C# 2005: The Base Class Library by Francesco Balena
  3. Professional ASP.NET 3.5: In C# and VB by Bill Evjen
  4. Programming .NET Components by Juval Lowy
  5. Debugging Microsoft .NET 2.0 Applications by John Robbins
  6. Professional ASP.NET 3.5 AJAX by Matt Gibbs

Design / Architecture / Guidelines

  1. Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries by Krzysztof Cwalina
  2. Microsoft® .NET: Architecting Applications for the Enterprise (PRO-Developer) by Dino Esposito
  3. UML Distilled: A Brief Guide to the Standard Object Modeling Language (3rd Edition) by Martin Fowler
  4. Software Systems Architecture: Working With Stakeholders Using Viewpoints and Perspectives by Nick Rozanski
  5. Practical Guidelines and Best Practices for Microsoft® Visual Basic® and Visual C#® Developers  by Francesco Balena
  6. Agile Software Development, Principles, Patterns, and Practices by Robert C. Martin

Concepts 

  1. Don’t Make Me Think: Common Sense Approach to Web Usability, 2nd Edition by Steve Krug
  2. The Pragmatic Programmer: From Journeyman to Master by Andrew Hunt
  3. Code Complete: A Practical Handbook of Software Construction by Steve McConnell

Source Control / Build

  1. Inside the Microsoft® Build Engine: Using MSBuild and Team Foundation Build by Sayed Ibrahim Hashimi
  2. Professional Team Foundation Server by Jean-Luc David

Any other suggestions guys, particularly for web services, security and unit testing?

Programming for Beginners

September 22, 2009 Leave a comment

Really there are cool changes happening in Microsoft.

Today I learnt about this exiting new site for beginner programmers (from Scott Hanselman ) which was created to educate the beginner programmers. I know quite a few beginner programmers to whom I would send this link. If you guys know some kids/beginners, do the same.

As expected there are different tracks waiting for the beginners to choose from
1. Web Track: This track covers everything the beginners need to learn about how the internet works and how to create great (!) web applications. There are some tips and tricks too that would give more insight.
2. Windows Track: Great place to learn windows programming, graphics etc.
3. Aspiring Professional: After mastering basics of programming, the beginners can utilize this place to gain more in depth knowledge. There are some advertisements and tricks done here to make beginners spend money on training and upgrading to professional visual studio from free visual studio express.
4. Kids Corner: Why the kids always get the corner? No don’t think this corner is only for kids. This also includes video tutorials for Parents and Teachers who wants to teach the kids.

Beginners can choose either tracks 1 and 3 (web developer) or 2 and 3 (windows developer) or 1,2 and 3 (know-it-all, web-windows developer).

Beginners must install Silverlight to watch and learn all these videos; which is free and can be installed by clicking on the “Silverlight: Click to install the required version”.I think, Microsoft is violently marketing Silverlight. Cannot blame them, they are actually running out of time. They need all the machines to have Silverlight, only then they will be able to tackle the fierce competition from flash. Anyway this is out of our current topic.

There are really quite a lot of learning resources available now for kids and students who really want to do some programming. It is not like the time when I studied programming in my college. Few weeks before I and my friend Sajid were talking about this problem.

One of Sajid’s friends was doing a part-time job of “helping” university students to develop their projects. Actually he is not just helping; he is developing the whole project and selling it for a cost. This is not helping really. This actually spoils the kid and never gives him a chance to learn on his own.

@“Helpers”: Never and ever develop and sell projects to university students. If you have free time try to educate them and give pointers to learning resources.

@“Kids / Beginner Programmer”: Don’t rely on the “helpers”; there is lot of resources available now in the internet. Use them and build your own career. Happy programming!

Categories: .Net, ASP.NET