Also the Beginner Track was broken in to two different tracks this year, Beginner I (which I was apart of) is designed for those of you who are brand new to software development and want to get a feel for the tools, Beginner II is designed for those of you who already have a handle on the tools and want to start learning a little more about developing software. Both are great tracks and both had a very good showing, so if you know a high school student, college student, or seasoned learner that wants to start developing software, they should stay tuned and check back with the Philly.NET website in late March 2010.

Also if you weren’t there, I really hope you can make the next one in April. You will not be disappointed. The two presentations that I attended this Code Camp were:

1. Al Katawazi’s presentation on using ASP.NET MVC in the Enterprise.
2. Dani Diaz’s presentation on the Managed Extensibility Framework (MEF)

Both presentations were interesting and engaging and I highly recommend them as speakers.

While I am on the subject, if you have a chance, and were present for my talks, please take the time to respond to the survey of what you thought about Philly Code Camp 2009.2 and specifically my talks. This is the only way that Philly.NET Users Group can get feed back on what to do better next time and what worked great this time around. I look forward to the feedback. And there is a Zune HD in it for one lucky winner.

• Code Camp 2009.2 Evaluation

As I promised in my talks here are the downloadable resources that I used as part of my presentation.

Beginner I Track – 10:30 AM – Gooey GUI… Programming in Visual Studio

• Microsoft Visual Studio Express
  http://www.microsoft.com/express/download
• Microsoft SQL Server Express w/ Tools
  http://www.microsoft.com/express/sql/download
• Sara Ford’s Blog:
  http://blogs.msdn.com/saraford
• And Sara Ford’s best selling book on the subject

Tools Track – 3:30 AM – Visual Studio 2010 Extensibility

• MSDN Visual Studio Extensibility
  http://www.msdn.com/vsx
• Visual Studio Extensibility Team Blog
  http://blogs.msdn.com/vsxteam
• Samples shown during demonstration
  http://editorsamples.codeplex.com/
• My project for the URL Rewriter showing during demonstration
  http://urlrewriter.codeplex.com/

• Lots of code, just say no to slides!
• 8 hours of presentations
• 60 sessions (8:30, 10:00, 12:30, 2:00, 3:30)
• 12 tracks including two hands-on Beginner rooms and the Bonus Track
• 600 seats with tables (laptops welcome)
• Free breakfast, lunch, and afternoon snack (expanded menu!)
• Raffles and prizes at 5:00
• Convenient parking
• After hours party in Ambler (network with speakers and attendees)

All of this is made possible by the Gold partners (Component One, Hosting.com, TEK Systems), Silver partners (Pearson, Redgate, Telerik) and the Platinum site sponsors (DeVry University, Microsoft).

My First Presentation at 10:00

I have been asked back to do my presentation from April again in the newly expanded Beginner I track at 10:00 AM.  The abstract for this talk is as follows:

This session explores the Microsoft Visual Studio development environment and how it is used to develop Web and Windows applications.  The topics include:

• The IDE
• Solutions and projects
• Templates
• Files created
• The debugger
• The configuration file

If you are going to be attending this talk please bring Visual C# 2008 Express with you, that is going to be the main tool I will be using to demonstrate the features of Visual Studio.

My Second Presentation at 3:30 PM

I will also be doing a new presentation on extending Visual Stuido 2010 in the Tools track at 3:30 PM.  The abstract for this is as follows:

I will be showing the basics of how to get started on extending Visual Studio 2010 for custom highlighting and intellisense support for custom Domain Specific Languages that may be used with in a company for configuration or custom processing. I will be using a real world example, of how I am extending visual studio to support the coding of the Apache mod_rewrite style configuration files that are used in my URL Rewriter that was featured in PDC 2008 last year. http://urlrewriter.codeplex.com

If you are going to be attending this talk please bring Visual Studio 2010 with you and the Visual Studio SDK already installed.

The Keyboard Command Way

Shift+Ctrl+Alt+O

The Registry Hack Way

• Show Menu for CodeRush Xpress (x86)
• Show Menu for CodeRush Xpress (x64)

I really wish DevExpress would stop treating the registry as a dumping ground and creating a new parallel registry path with each new install, it makes customizing the registry settings very difficult to keep up with. I could see it for each major version, but common is a new registry path really needed for each minor version?

Many years ago, I had read the articles by K. Scott Allen and Brad Abrams, explaining why the original FxCop rule, “Do not declare explicit static constructors”, existed and the IL command beforefieldinit, that caused the FxCop rule to trigger and cause performance issues.  Jon Skeet explained it best in a recent Stack Overflow post.

Basically, beforefieldinit means “the type can be initialized at any point before any fields are referenced.”

In theory that means it can be very lazily initialized – if you call a static method which doesn’t touch any fields, the JIT doesn’t need to initialize the type.

In practice it means that the class is initialized earlier than it would be otherwise – it’s okay for it to be initialized at the start of the first method which might use it. Compare this with types which don’t have beforefieldinit applied to them, where the type initialization has to occur immediately before the first actual use.

But, I had assumed that since this rule was never include in the Code Analysis (FxCop replacement) part of Visual Studio 2005, 2008, or 2010 that it was a non issue in .NET 2.0 and forward. Since all these previous credible articles that I could find were run against the .NET 1.1 framework.  But I had never really looked in to it until now.  The first thing I did was create the following program to test 8 different senarios where a static constructor could be created by the compiler or was created by me to test the performance differences.

• Program.cs

Each of the 8 senarios had a public interface like the following:

class StaticX
{
    static string Name = "Nick Berardi";
    static string GetName() { /* to make sure the Name property was referenced */ }
}

The scenarios were broken down as follows:

1. Static1: static class, name set on field
2. Static2: static class, name set in constructor
3. Static3: static class, name set in property
4. Static4: static class, name set on field and in constructor
5. Static5: name set on field
6. Static6: name set in constructor
7. Static7: name set in property
8. Static8: name set on field and in constructor

I then used reflector to give me the following IL dump of the code.

• Program.il

If we look at the IL code for each of these classes and static constructors we start finding some interesting patterns in how the compiler optimizes the code.

Static1, Static2, Static5, and Static6

All the the following static constructor (.cctor()), which is interesting because half of them defined the code in the static constructor and half defined the code by setting the field during initialization.

.method private hidebysig specialname rtspecialname static void .cctor() cil managed
{
    .maxstack 8
    L_0000: ldstr "Nick Berardi"
    L_0005: stsfld string ConsoleApplication1.Program/Static1::Name
    L_000a: ret
}

Static3 and Static7

These do not have any static constructor, which we could have probably guessed because there was no constructor defined and no fields set during intialization of the classes.

Static4 and Static8

These do not match any of the other static constructors we have seen, probably because there is an operating occurring in them.

.method private hidebysig specialname rtspecialname static void .cctor() cil managed
{
    .maxstack 8
    L_0000: ldstr "Nick"
    L_0005: stsfld string ConsoleApplication1.Program/Static8::Name
    L_000a: ldsfld string ConsoleApplication1.Program/Static8::Name
    L_000f: ldstr " Berardi"
    L_0014: call string [mscorlib]System.String::Concat(string, string)
    L_0019: stsfld string ConsoleApplication1.Program/Static8::Name
    L_001e: ret
}

There is one more place we are going to want to pay attention to before we start looking at the performance, and I sort of alluded to this at the beginning of the article. That is the IL for the class definition:

.class abstract auto ansi sealed nested public beforefieldinit Static1
.class abstract auto ansi sealed nested public                 Static2
.class abstract auto ansi sealed nested public beforefieldinit Static3
.class abstract auto ansi sealed nested public                 Static4
.class          auto ansi        nested public beforefieldinit Static5
.class          auto ansi        nested public                 Static6
.class          auto ansi        nested public beforefieldinit Static7
.class          auto ansi        nested public                 Static8

Please note that I added in the spaces to show the differences between the definitions.

You will notice that the abstract and sealed are missing from Static5 – Static8, don’t worry about those keywords they are the difference between a static class and an instantiatable class. The one we are about is beforefieldinit, which is only added to classes that don’t already contain a static constructor. The definition of how this works has changed slightly from the original specification (ECMA-335). Here is the break down as related to .NET Framework releases:

• 1st Edition (December 2001) – .NET 1.0
• 2nd Edition (December 2002) – .NET 1.1
• 3rd Edition (June 2005) – .NET 2.0, .NET 3.0, .NET 3.5
• 4th Edition (June 2006) – .NET 2.0, .NET 3.0, .NET 3.5 (Changes from the previous edition were made to align this Standard with ISO/IEC 23271:2006.)

I have marked changes that have been added since the first edition.

The semantics of when and what triggers execution of such type initialization methods, is as follows:

1. A type can have a type-initializer method, or not.
2. A type can be specified as having a relaxed semantic for its type-initializer method (for
   convenience below, we call this relaxed semantic BeforeFieldInit).
3. If marked BeforeFieldInit then the type’s initializer method is executed at, or sometime before,
   first access to any static field defined for that type.
4. If not marked BeforeFieldInit then that type’s initializer method is executed at (i.e., is triggered
   by):
   • first access to any static field of that type, or
   • first invocation of any static method of that type or
   • first invocation of any constructor for that type. (new in 3rd edition)
5. Execution of any type’s initializer method will not trigger automatic execution of any initializer
   methods defined by its base type, nor of any interfaces that the type implements

START — The following is new to the 3rd edition.
For reference types, a constructor has to be called to create a non-null instance. Thus, for reference types, the
.cctor will be called before instance fields can be accessed and methods can be called on non-null instances. For
value types, an “all-zero” instance can be created without a constructor (but only this value can be created
without a constructor). Thus for value types, the .cctor is only guaranteed to be called for instances of the value
type that are not “all-zero”. [Note: This changes the semantics slightly in the reference class case from the first
edition of this standard, in that the .cctor might not be called before an instance method is invoked if the 'this'
argument is null. The added performance of avoiding class constructors warrants this change. end note]
END

[Note: BeforeFieldInit behavior is intended for initialization code with no interesting side-effects, where exact
timing does not matter. Also, under BeforeFieldInit semantics, type initializers are allowed to be executed at
or before first access to any static field of that type, at the discretion of the CLI.
If a language wishes to provide more rigid behavior—e.g., type initialization automatically triggers execution
of base class’s initializers, in a top-to-bottom order—then it can do so by either:

• defining hidden static fields and code in each class constructor that touches the hidden static field of its
  base class and/or interfaces it implements, or
• by making explicit calls to System.Runtime.CompilerServices.Runtime-HelpersRuntimeHelpers^{3rd edition}.RunClassConstructor
  (see Partition IV).

end note]

So to analyze what has changed, it looks like some major changes took place in the CLR for the .NET 2.0 framework on how and when static constructors should be initialized. In K. Scott Allen’s post that I referenced above he concluded that classes with out the beforefieldinit IL command ran 5 times faster on the .NET 1.1 framework. Lets see if that still holds true for the .NET 2.0 framework (and .NET 3.0 and 3.5 which run off the same CLR as .NET 2.0).

To test this, I ran each of the 8 scenarios through a loop about 2.15 billion times. Or Int32.MaxValue. Then I repeated the process 5 times (for those counting each one was ran about 10 billion times), and averaged the results and came up with these numbers:

1. Static1: 05.7505114 seconds (static class, name set on field)
2. Static2: 07.4920393 seconds (static class, name set in constructor)
3. Static3: 11.6594099 seconds (static class, name set in property)
4. Static4: 08.3254804 seconds (static class, name set on field and in constructor)
5. Static5: 05.7362727 seconds (name set on field)
6. Static6: 07.6593536 seconds (name set in constructor)
7. Static7: 12.4801669 seconds (name set in property)
8. Static8: 08.3191176 seconds (name set on field and in constructor)

We can obviously throw out the outliers of setting the name in the property because they where 2 times slower than the fastest method. And we can also throw out the name being set half in the field and half in the constructor, because this is obviously not the best performing and is also not really the best way to code this type of field, and it was only in there as a baseline for doing both a field and constructor setting in the same class.

So lets look at the actual numbers of field vs constructor:

The performance points are pretty much a wash between static class and instantiatable class, and there is essentially no difference between the field and constructor for everyday normal programs to think about changing how you create your static-code as related to fields or constructors. The difference was only 30%, while that sounds like a lot the difference was only 2 seconds over 2.15 billion times run, so we are really talking about fractions of milliseconds per instance. In addition it was no 500% reported by K. Scott Allen against .NET 1.1 back in 2004.

You can draw your own conclusions. But my recommendation is to NOT spend your time changing your code from the use of static constructor to fields, because you won’t find the performance gains in your application. Spend the time on something useful, like the amount of data you are pulling from the database or other places.

I think we can finally put this issue to rest and say that there is no more performance penalty to a degree that every day programmers should care about if you are using the .NET 2.0 framework or forward. Which means I probably guessed correctly as to why they removed it from the Code Analysis rules in Visual Studio 2005.

Update: I had to run each static class individually again to get the correct results, because after I had published this I started playing around with other scenario and noticed that there seemed to be an optimization of static constructor classes (without beforefieldinit), with the same constructor signature, that got loaded later. With the new results, there is now there is virtually no difference between static classes and instantiatable classes which is what I sort of assumed would happen from the beginning.

If anybody knows why static constructor classes that share the same signature would be optimized can you please let me know, this is a new mystery to the static constructor debate.

I recently came to realize that our website situation was growing out of hand. We had a corporate website, an intranet site, and even a site for web access to email. All of these sites were scattered across multiple servers and each was on a unique port. While this worked, it was not simple. Each new site had to have a new rule configured in the firewall, and who wants the hassle of putting port number at the end of a url?

The solution to this mess turned out to be adding a reverse proxy to our network. By simply providing different urls (www.example.com, mail.example.com) the incomming traffic can be anlayzed by the proxy server and routed to the appropriate internal web server. All the incomming traffic is sent over the default port 80 so the end user never sees any difference. That’s exactly what I wanted, great!

Since our sites are all built upon ASP.NET and hosted on IIS6 the natural option for this was Microsoft ISA Server. Unfortunately, the $1500 cost was way beyond our small company’s internal IT budget. So it was off to Google for me, and after some searching, it appeared that the open source project Url Rewriter by ManagedFusion [sic] seemed to fit the bill.

Thanks for the great write up John.  I hope to be including John’s article in an up coming FAQ wiki on my CodePlex project site in the near future.

TF53002: Unable to obtain registration data for application VersionControl.
TF30040: The database is not correctly configured. Contact your Team Foundation Server administrator.
TF30059: Fatal error while initializing web service
TF30063: You are not authorized to access myserver.443. (type TeamFoundationServerUnauthorizedException)

This is very weird because I was just working on it earlier this week, without any issues.  So I go in to check the recent update history of Windows Update and to my surprise I see 13 new updates, mostly security related.  And since TF30063 is a security related exception, I think I found the culprit.  Here are the KB articles of the updates that were done for reference:

1. KB956744
2. KB973540
3. KB947319
4. KB971032
5. KB960859
6. KB971557
7. KB973869
8. KB973507
9. KB973354
10. KB961371
11. KB971657
12. KB890830
13. KB973815

So I started searching the web for each of those error messages, and I found a ton of old articles related to the SP1 release of Team Foundation Server.  However I upgraded about a year ago to SP1 so I doubt that is the issue.  But during my searching I found an obscure article referencing KB926642, which on first pass I just brushed off as not being the issue.  But as I started reading it I remembered that I do access my server through a CNAME address, and one of these security updates might have disabled Windows Authentication through CNAME’s.  So I tried as the article suggested.

\\myserver\c$ — works
\\myserver-cname\c$ — tells me I am not authorized

So I followed Method 1 in KB926642:

Method 1 (recommended): Create the Local Security Authority host names that can be referenced in an NTLM authentication request

To do this, follow these steps for all the nodes on the client computer:

1. Click Start, click Run, type regedit, and then click OK.
2. Locate and then click the following registry subkey:HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\MSV1_0
3. Right-click MSV1_0, point to New, and then click Multi-String Value.
4. In the Name column, type BackConnectionHostNames, and then press ENTER.
5. Right-click BackConnectionHostNames, and then click Modify.
6. In the Value data box, type the CNAME or the DNS alias, that is used for the local shares on the computer, and then click OK.Note Type each host name on a separate line.

   Note If the BackConnectionHostNames registry entry exists as a REG_DWORD type, you have to delete the BackConnectionHostNames registry entry.

7. Exit Registry Editor, and then restart the computer.

And everything is working great now.  So if you are using a CNAME with your TF server, you may want to consider adding the CNAME in to the BackConnectionHostNames.  It will not only help your TF server, but all your other connections to this server that use Windows Authentication and the CNAME.  Hope this helps somebody else besides me.

So some of the oddities that emerged to me are:

• The word “Infinity” is equal to the type Infinity, however “true” or “false” don’t equal true or false respectively.
• " " == 0 == false and also "" == 0 == false, however " " != ""
• Update Just noticed that NaN != NaN but Infinity == Infinity

If you would like to try this your self, or want to add to it, here is the code that I used.

var values = [null, undefined, true, false, -1, 0, 1, NaN, Infinity, "", " ", "null", "undefined", "true", "false", "-1", "0", "1", "NaN", "Infinity"];

document.write("<table><thead><tr><th></th>")
for (var x = 0; x < values.length; x++) {
	document.write("<th>" + (x > 8 ? "\"" : "") + values[x] + (x > 8 ? "\"" : "") + "</th>");
}
document.write("</tr></thead><tbody>");
for (var i = 0; i < values.length; i++) {
	document.write("<tr>");
	document.write("<th>" + (i > 8 ? "\"" : "") + values[i] + (i > 8 ? "\"" : "") + "</th>");

	for (var j = 0; j < values.length; j++) {
		var output = values[i] == values[j];

		document.write("<td style=\"text-align:center;" + (i == j ? "background-color:black;" : (output ? "background-color:green;color:#00AF33;" : "color:#e0e0e0;")) + "\">");
		document.write(output ? (i > 8 ? "\"" : "") + values[i] + (i > 8 ? "\"" : "") : "--");
		document.write("</td>");
	}

	document.write("</tr>");
}
document.write("</tbody></table>");

I think Scott really hit the nail on the head when he said this about JavaScript coercion.

In this economy you have to do everything to keep your skills fresh and current so that employers find you a desirable hire. I really though the tips provided in 8 Ways to Recession-Proof Your Programming Career where spot on when this article came out last year. And now that the TechRepublic has released 10 kills developers will need in the next 5 years. I have decided to give you some of my favorite Wrox books that align very well to this TechRepublic article.

The Economy may or may not seem so bleek anymore depending on who you talk to, but the message is still the same, keep your skills current and marketable. That is why I put together the list originally and it is still why I am porting it to Listmania.

Click here to check out my “Recession Proof Your programming Skills” Listmania list.

I will try to keep this up to date with new books I find useful and marketable in the way of programming skills, if you have any comments or suggestions for my list please feel free to leave them below.

Eventually Rory Becker, who is a CodeRush fanatic, turned me on to two different way you can access the Options menu of CodeRush Xpress.

The Keyboard Command Way

Shift+Ctrl+Alt+O

The Registry Hack Way

• Show Menu for CodeRush Xpress (x86)
• Show Menu for CodeRush Xpress (x64)

Hope this helps somebody besides me.

Update: Sorry about that had a server configuration mishap for delivering Windows Registry files, I have moved them to my Google Code download location.

Applies to:

Security Update for Microsoft Visual Studio 2008 Service Pack 1 (KB971092)

Symptoms:

The update installs successfully and but will be offered again by Windows Update as a new update. This can be repeated indefinitely.

or

the standalone installer tells you that this update “does not apply, or is blocked by another condition on your system”.

Workaround (found here):

1. Download the stand-alone version of VS90SP1-KB971092-x86.exe.
2. Start the installation VS90SP1-KB971092-x86.exe
3. Wait for the error message to come up – do not close the window
4. Copy the temp. folder where the patch has been unpacked to a new folder, for example onto your desktop.
5. Close VS90SP1-KB971092-x86.exe that you started in step 2.
6. Navigate to {Program Files}\Microsoft Visual Studio 9.0\Common7\Tools and find vsvars32.bat.
7. Change the permissions on the file to allow everyone to edit it.
8. Start VS90SP1-KB971092-x86.msp from within the saved folder and the process should complete.
9. You may want to reset permissions that you gave in step 7.