There are a few areas in jQuery that have seen extensive changes since 1.3.2 was released:

• live was drastically overhauled and now supports submit, change, mouseenter, mouseleave, focus, and blur events in all browsers. Also now supports context and data.
• append, prepend, etc. have been heavily optimized.
• add has been adjusted to always return elements in document order.
• find, empty, remove, addClass, removeClass, hasClass, attr, and css have been heavily optimized.

Full details concerning the release are forthcoming – for now we just need your help in catch regressions. Some more details can be found in John Resig’s keynote at the 2009 jQuery Conference.

Grab the code:

• Regular: http://code.jquery.com/jquery-1.4a1.js
• Minified: http://code.jquery.com/jquery-1.4a1.min.js

NOTE: If you’re using jQuery 1.4a1 and you run into an error please make sure that you’re using the regular version of the code, it’ll make it easier to spot where the error is occurring.

The Subsonic project attempts to do something similar for SQL. Consider this SQL query:

SELECT * from Customers WHERE Country = "USA"
ORDER BY CompanyName

Here’s how we would express that same SQL query in SubSonic’s fluent interface:

CustomerCollection c = new CustomerCollection();
c.Where(Customer.Columns.Country, "USA");
c.OrderByAsc(Customer.Columns.CompanyName);
c.Load();

I’ve mentioned before that I’m no fan of object-oriented rendering when a simple string will suffice. That’s exactly the reaction I had here; why in the world would I want to use four lines of code instead of one? This seems like a particularly egregious example. The SQL is harder to write and more difficult to understand when it’s wrapped in all that proprietary SubSonic object noise. Furthermore, if you don’t learn the underlying SQL– and how databases work– you’re in serious trouble as a software developer.

Enough of the History lesson, why are you writing this post

Well the reason for this post is two fold, I haven’t written a post in a couple of weeks, and I wanted to write about my own CodingHorror moment, while working with the Entity Framework, that solved a big problem I was having with getting the LIKE statement to work in LINQ.

I am working with a client of mine trying to expose their data to the web via a simple REST service.  Their whole database model has been constructed in the Entity Framework in a simple active record format.  One of the requirements, I was given, was to support wildcards on a couple of the input fields.  I thought this was no big deal, because I knew that the StartWith, EndsWith, and Contains methods of the System.String object, when used in LINQ, translated down to the SQL LIKE operator. 

However at the time I didn’t anticipate how much of a pain in the butt it was to actually figure out which of these three methods I should use depending on where the wildcard was placed in the string.  And how I would support a wildcard that was placed in the middle of a string.

Enter Entity Frameworks’s parameterized Where method

The parameterized Where method, of the ObjectQuery<T> object, really saved my butt.  It allowed me to produce the exact effect of the query I was looking for, and with out a lot of hacking.  Here is what I did:

if (!String.IsNullOrEmpty(toAddress))
	table = table.Where(
		"it.ToAddress LIKE @toAddress",
		new ObjectParameter("toAddress", toAddress)
	);

var results =
	from result in table
	where result.Account.AccountId == accountId
		&& result.DateTime >= startDate

return View(results.ToList());

The best part of the above code is that I can still use LINQ, and jump in to standard SQL syntax when the LINQ syntax fell short. 

This is my opinion gives the Entity Framework a step above the rest, because it means that I don’t have to complicate my life and my program by moving to a stored proc or making the whole select statement inline-SQL (which I wouldn’t ever do). 

Features like this that make developing software easier, and obviously have the programmer in mind, are what we should all strive for.  I like this for the very fact that the Entity Framework team has acknowledged that LINQ, while a wonderful addition to .NET, doesn’t meet all the needs for pulling data from the database and they sought to minimize the short comings by allowing developers to jump back in to the natural SQL language.  This is a wonderful addition in my book.

One of the companies that has gone way beyond standard application responsiveness is a company called thirteen23.  They put an amazing level of detail and thought in to every action that the user performs.  A great example of their skilful approach to application development is a WPF Twitter client they call Blu.  An example of the level of thought they provide is their reply feature they offer.

Not only are they solving a problem with this user interaction, but they are providing a feedback mechanism, with animation and context switching, to the user.  If you haven’t already download the Blu client, you should definitely take a look at it, and notice all the subtle usability features that make it a really great tool.

A feeback mechanism we all can do

I don’t even think I could achieve what thirteen23 has achieved with Blu or even write up a good blog post about everything they have done right with this Twitter client.  But one thing that I can do is show you how you can add an attractive loading panel to your website, with relatively no effort and that will provide ample feedback for your users during an AJAX request.  For my example I am going to be using jQuery, but what I am showing you is easily ported to other JavaScript frameworks.

The example

The first thing I have is this pretty graph with a couple of inputs and an Update button.

When I click the update button is does a standard jQuery.get(…) command against my web server to pull the new graph data.  However depending on the date range, which dictates the number of plot points I need to pull for the graph, it can take anywhere from a half second to 5 seconds to pull all the data necessary to show the graph. A half second isn’t bad, because that is just about fast enough where they consider the new graph showing up a adequate response to their action of clicking the Update button.  However 5 seconds is really pushing their patients.  So in order to give the feeling of something is really happening because of their button click, we need to provide a feedback mechanism.  The feedback mechanism I choose to implement was a standard loading window.

First things first

The first things we need to do is setup the necessary HTML elements and CSS styling.  Before I went off and added in my HTML and CSS, I first needed to pick out a loading animated image that I liked and worked with the look and feel of the website.  Lucky for me there is a great AJAX Loader generator at a site called http://www.ajaxload.info/.

After I found the image I was interested in using with my website, I then needed to add the HTML.  The first thing I needed to do was create the desired content area, or update pane, that would be the focus area of the update.  I did this by creating a wrapper around my graph, called report-pane, and then added an element called report-loading, which would be the loading window that would be styled by the CSS.

<div id="report-pane" style="position: relative;">
	<div id="report-loading" class="loading"><img src="/Content/images/ajax-loader.gif" width="32" height="32" /><br /><strong>Loading</strong></div>

	<!-- report here -->
</div>

The next thing I did was add in the CSS that would render my loading window in an appealing way that fit in to the design of the site.

/*  Loading
**********************************************************************/

.loading {
	position: absolute;
	display: none;
	border: 1px solid #5c9ccc;
	padding: 2px;
	background-color: #5c9ccc;
	color: #ffffff;
	opacity: 0.90;
	-webkit-border-radius: 5px;
	-moz-border-radius: 5px;
	width: 100px;
	height: 50px;
	text-align: center;
	z-index: 100000;
}

After I had the necessary markup and styles in place, the update-loading element I added to the HTML looked like this:

Now I can move on to creating the actual user interaction.

Enter jQuery

jQuery has a couple nice global events that trigger whenever an AJAX request being made.  The two we are going to use today are called ajaxStart and ajaxStop.  The method names are a pretty good indicator of their functionality, so I won’t bother going in to detail.

The actual jQuery JavaScript code for getting this to display is pretty trivial.  Which speaks more to the power and flexibility of jQuery, more than anything else.

$("#report-pane").ajaxStart(function() {
	var width = $(this).width();
	var height = $(this).height();

    $("#report-loading").css({
		top: ((height / 2) - 25),
		left: ((width / 2) - 50)
    }).fadeIn(200);    // fast fade in of 200 mili-seconds
}).ajaxStop(function() {
	$("#report-loading", this).fadeOut(1000);    // slow fade out of 1 second
});

There are two things you should pay special attention to in the above code.  The first is the fact that I want the loading screen to be positioned in the center of the graph so that, so that it is very apparent to the user what is being updated, and because their attention is already on the graph as the main focal point of their clicking of the Update button.  I do this by taking half the width and height of the report-pane and subtracting the size of the report-loading box, this will give me the x and y coordinates at which to place the report-loading box inside the report-pane.

The second thing you should take note of is that I do a quick fade in of 200 mili-seconds, so that the loading box appears almost instantaneously after they have clicked the Update button.  However on the face out, after the AJAX request has finished, I want them to really notice that the action has completed so I make the face-out 5 times longer than the fade in.  This provides enough time for them to notice that the action has completed and that the plot points being shown in the graph have been updated.

Final Result

And here is what the final result looks like, after adding only a handful of code to my already existing application.

Not bad huh?  And it didn’t even require any process change to my already working application.  It was really that easy, so you really have no excuse for not adding a little flare and usability to your web application.  Your users will thank you by lowering their anxiety level a little by not having to wonder if that button they just clicked actually did anything.

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.