Every once in a while, Visual Studio 2008 will lock up on me. When it was in beta and even after release, I ran into a situation where it put up a dialog saying “Blah blah blah” with the options:

• Switch to application
• Continue waiting

From someone, probably either directly from John Robbins or via one of the many blogs he has recommended through his presentations, I learned that this was being caused by a managed debugging assistant. Looking around on the web, it seems that this bug has been known for quite a while. Here is the issue and why it happens as explained by a Jim Stall from the Visual Studio team (link to post):

It is possible for this MDA to be falsely activated when all of the following conditions are met:
    * An application creates COM components from STA threads either directly or indirectly through libraries.
    * The application was stopped in the debugger and the user either continued the application or performed a step operation.
    *Unmanaged debugging is not enabled.

The reasoning is that:
1) When you’re stopped in the debugger while managed-only debugging, unmanaged threads are still running. This means that any unmanaged threads that are waiting on some timeout from managed code will continue to run. The unmanaged thread will see the timeout fire, but it won’t realize that the managed thread is actually stopped by the debugger. Thus the managed thread looks it’s deadlocked.  This is not an issue when unmanaged debugging because then the timeout thread is also frozen when stopped in the debugger, and so the timeout won’t fire.

2) The finalizer for an STA COM objects needs to run code on the STA thread. So there’s some cross-thread stuff between the finalizer thread and the STA thread.

So the STA thread may be blocked by the debugger (since the whole managed process is frozen at a breakpoint), while the timeout check (on an unmanaged thread) is still ticking.

This is a race because it needs the finalization and debugger event to happen at just the right windows.
We assessed that this scenario as a rare situation. I’d expect you to see this only on very rare occasions (due to prerequisite timing issues).
If you are hitting this bogusly, one workaround is to disable this specific MDA.

Let’s walk you through disabling the specific MDA, since this problem still exists and is not as rare as these guys think. I don’t get the issue when debugging normally, but I will get it when I run Visual Studio as an admin. Running Visual Studio 2008 as admin is required if you want to deploy applications straight over to the same machine’s IIS instance-something I do often enough. Note: I haven’t run into this issue in a non-admin context in several months. I think the two conditions are somehow linked.

Please note-you have to run this sequence for every project. VS2008 will not remember your settings across invocations.

1. With an open project, go into the menus and select DebugàExceptions.
2. Expand the Managed Debugging Assistants node.
3. Select ContextSwitchDeadlock and uncheck it.
4. Click OK.

I hope this helps a few other brave souls out there.

Over the past month, I’ve finally taken the plunge and decided to finally read those classic technical books that everyone seems to have read (though that many have only skimmed). I’ve also been reading oddball classics that are recommended by acquaintances and folks in the know. As for the big classics that I’ve read since May 1:

• The Algorithm Design Manual by Steve Skiena
• Programming Pearls by Jon Bentley
• Peopleware by Tom DeMarco and Timothy Lister
• The Mythical Man-Month by Frederick Brooks

I’ve also been paging through my Knuth’s again. Why, oh why would I be doing this? First off, I love the act of designing systems, writing code, and just geeking out in my chosen profession. Second, I know that I needed to read these classics so I could stop being an architect with no grounding in classic computer literature. I mean, I knew what the books were all about, but that was only through someone else’s eyes, not my own. So, with this journey still in motion, what have I been learning?

First, I needed a refresher on my algorithms. I was able to get most of the exercises in Programming Pearls and Skiena with a little bit of thought and some time by a compiler. It felt good to go through Bentley’s text and figure out the really advanced, best performing solutions to many problems. It was a morale boost to see that I could still figure this kind of thing out with just a little bit of effort.

From Peopleware, I took many ideas I have for this programming shop I want to start up ‘someday’ and refined the heck out of a bunch of ideas. For example, did you know that most people find performance reviews to be demotivating? I didn’t. I thought I was the oddball that hates performance reviews and would prefer life much better if I never got another one. It turns out that no one likes these-they are stressful. Unfortunately, I also learned some things about businesses I’ve been introduced to in my area. There are a lot of poisonous businesses out there taking a great profession and turning it into something where you feel odd to be one of the following:

1. A proud, 36 year old developer. In my opinion, that’s still young. Yet, many folks in the profession stop coding much before this age. I’m SOOOO glad I’m not one of those people.
2. Unwilling to ship because the quality bar is not only low, it doesn’t exist. Apparently, the shipping feature matters even when things aren’t right.
3. Unit testing is an OLD idea. JUnit, NUnit, and other unit testing tools are not new ideas. Shoot, Fred Brooks talks about unit testing going on for IBM back in the 1950s and 1960s. And yet, I still have a really hard time convincing folks that unit testing is important and it is an OLD idea. Unfortunately, fixing build breaks takes time when unit tests are present. They slow down development and make it take longer to get to the official test, file bug, fix, repeat cycle.

I find that my focus on my career is getting sharper. I’m seeing how I can make a difference, how to achieve it without stepping on toes and hurting feelings, and I’m seeing how fast people can be expected to change. People hate change and will only do so slowly when you are trying to move a group. People are more willing to change when they are being assimilated into a group-it feels better to be a part of the group than apart from the group. (yes, the use of ‘a part’ and ‘apart’ is intentional) At the moment, I’m trying to find a place where I can be a positive force for change and I need to make sure that I do this at a proper speed. If you know of a development shop that is top notch and just wants to get better, give me a call. I’d love to talk to you and find out what you are doing to make things happen.

I had a chance to see David Chappell speak at the Microsoft offices in Downers Grove this past week. If he is coming anywhere near you to talk on Software + Services, I recommend that you go see the talk. I’ve got a summary of what he covers here, but you’ve got to see him in person to get the talk. The man is an amazing communicator and helped me connect some dots that I hadn’t quite connected in a while-whether that was due to sloth on my part of great speaking on David’s part, I don’t knowJ.

Anyhow, here’s a few hundred words explaining some of what I got out of it.

Training Date: May 20, 2008, 1-4 PM

Location: Microsoft offices, Downers Grove, IL

Presenter: David Chappell, http://www.davidchappell.com/

Summary

The reliability of the Internet, relatively low cost of connectivity, and widespread presence of high bandwidth connections has provided a path for application architectures to evolve. Specifically, this set of changes allows application vendors to provide common applications to end users. Today, these common applications include e-mail, CRM, storage, web site hosting, mapping (ex. 1 Main St., Mundelein, IL), and database hosting. Providers host these services on the Internet, also called the ‘cloud’ by the software services community. These services commonly provide the following features:

• Data mobility: Consumers own their data and can change providers or move the data in house as needed.
• Application integration: The service in the cloud is part of a larger application used at the enterprise.
• Application customization: The service in the cloud may allow the consumer to customize the application to handle special business needs.

Two terms describe the different business models for the services in the cloud: Software as a Service, SaaS, and Software + Services, S+S. SaaS offers a complete software package in the cloud. SaaS instances may allow for integration and customization. SaaS does not provide much of a role for corporate IT departments outside of application development. S+S describes a hybridization between today’s common model of self-hosting applications and the SaaS world. SalesForce.com offers an example of a SaaS application. SalesForce.com manages all the data, the application uptime, etc. An S+S example is a bit more involved, but probably more common for businesses as it allows for control of the perceived competitive advantages of a business.

S+S includes the types of applications that use cloud services as well as custom, in-house services. For example, a business could host Exchange Server locally but make use of a service provider to handle advanced Exchange functionality such as Outlook Web Access, web calendaring, or discussion lists.

With terminology and ideas covered, what else does a business need to look out for? The business should evaluate the service provider in the same way that they would evaluate a packaged, installable software. Beyond that the consumer needs to decide if the service meets their needs.

In both packaged software and services, one must look at how the vendor is trying to lock in the consumer. This lock in happens in different ways. They may lock down data, making it difficult to move to a new vendor. They may also create a platform type of lock in. The platform lock in can cause many different kinds of problems. If the lock in is through the tooling and programming languages, a consumer may find it difficult to port customizations to equally good platforms. Likewise, it may prove difficult to find reasonably priced developer talent. For example, SalesForce.com uses the Apex programming language. Apex is specific to SalesForce.com and isn’t commonly available elsewhere. Other tools, like Microsoft Dynamics CRM and Google Apps, use common extension languages, allowing for a larger developer pool. Microsoft Dynamics uses .NET based languages and Google Apps uses Python.

I have a friend who teaches Computer Science. One of the things we’ve discussed is the need for students/entry level hires to really understand basic data structures. This is true even though most popular languages do the basic ones quite well (linked list, hashtable, queue, stack). A consequence of these things being in most languages is that many of today’s students aren’t being required to actually build these data structures as part of their education. Many problems in the work place involve situations where one needs to know the characteristics of the data structure in order to implement the most efficient algorithms. One acquires this knowledge through actually building the data structures at least once.

I believe that many of the folks who grew up programming for the web are getting to a point where their script skills will need to fill in these gaps in their education. Browser apps are approaching desktop applications in terms of presentation, interactivity, and capability. The next step in the evolution of browser applications will require developers to have knowledge of the basic data structures and their variance implementation options. The reason: unlike the desktop languages we all use, the browser’s programming language, JavaScript, doesn’t have any of these. (If I’m mistaken, let me know!)

Right now, I’m reviewing the data structures and algorithms that I learned during the first two years of college. I’m also trying to bring myself up on my level of understanding JavaScript. I think that some of these diversions might prove interesting to the world at large. Today, I’ve implemented a linked list. A linked list has the following characteristics:

1. Add at the front or end of the list takes O(1) time.
2. Extraction of the nth element takes O(n) time.
3. Insert at a given position, k, takes O(k) time.
4. Delete at a given position, k, takes O(k) time.

Linked lists are effective when typical usage of the list is in scanning all elements. A linked list is ‘nice’ to memory management. That is, the room needed for the list + one more linked list node is:

Z = (size of node) = ((size of data) + (reference to next node))

(total memory in use when adding a node) = Z x (number of nodes + 1)

This is an improvement over the typical JavaScript Array type whose worst case characteristics for adding one more element to the list is

Z = (size of node) = (size of data)

(total memory needed when adding a node) = Z x ((2 + growth size) x number of nodes)

In many algorithms for array growth, the algorithm calls for a doubling of the array’s allocated memory. The reason that so much memory is required is that arrays require contiguous memory in order to maintain O(1) lookup time at any given element.

A Doubly Linked List Implementation

A doubly linked list is a list that one can use to go both forward and backward from one node to the next. To accomplish this, I’ve created three classes:

function LinkedListNode() {

}

LinkedList.LinkedListNode = {

Data: null,

Next: null,

Previous: null

};

LinkedListNode keeps track of the data, the Next, and the Previous nodes. The algorithms involved all assume that the linked list Next and Previous members will only be other LinkedListNodes or null.

function LinkedListIterator(){}

LinkedListIterator.prototype = {

_current: null,

Current: function() {

var retval = null;

if (this._current != null)

{

retval = this._current.Data;

}

return retval;

},

Next: function() {

if (this._current != null)

{

this._current = this._current.Next;

}

return this._current != null;

},

Previous: function() {

if (this._current != null)

{

this._current = this._current.Previous;

}

return this._current != null;

},

HasData: function() {

return this._current != null;

}

};

LinkedListIterator allows one to go forward and backward within a LinkedList. The iterator can become invalid when it runs off the front or back of the LinkedList.

function LinkedList(){}

LinkedList.prototype = {

_head: null,

_back: null,

_length: 0,

Add: function(data) {

var newNode = new LinkedListNode();

newNode.Data = data;

if (this._head == null)

{

this._head = newNode;

this._back = newNode;

}

else

{

newNode.Previous = this._back;

this._back.Next = newNode;

this._back = newNode;

}

++this._length;

return newNode;

},

RemoveAt: function(index) {

var currentIndex = 0;

var nextNode = this._head;

while (nextNode != null && currentIndex < index)

{

++currentIndex;

nextNode = nextNode.Next;

}

if (currentIndex == index)

{

nextNode.Previous.Next = nextNode.Next;

if (nextNode.Next != null)

{

nextNode.Next.Previous = nextNode.Previous;

}

}

return nextNode;

},

Length: function(){

return this._length;

},

InsertAt: function(index, data) {

var currentIndex = 0;

var nextNode = this._head;

var newNode = new LinkedListNode();

newNode.Data = data;

 

if (index == 0)

{

// Insert at head

if (this._head == null)

{

this.Add(data);

}

else

{

newNode.Next = this._head;

this._head.Previous = newNode;

this._head = newNode;

++this._length;

}

}

else if (index >= this._length)

{

// Add to the end.

this.Add(data);

}

else

{

// Insert in the middle

while (nextNode != null && currentIndex < index)

{

++currentIndex;

nextNode = nextNode.Next;

}

if (currentIndex == index)

{

nextNode.Previous.Next = newNode;

newNode.Previous = nextNode.Previous;

newNode.Next = nextNode;

nextNode.Previous = newNode;

++th
is._length;

}

}

return nextNode;

},

GetIterator: function(){

var retval = new LinkedListIterator();

retval._current = this._head;

return retval;

}

};

Finally, this is the linked list data structure. It allows you to insert at a given location, remove a given item, add an item to the end of the list, and can create a bi-directional iterator to allow you to walk the list from front to back and to the front again. Since I’m a Windows guy, I tested out the structure using cscript.exe.

function DisplayList(list)

{

var iterator = list.GetIterator();

 

 

if (iterator.HasData())

 

{

 

do

 

{

WScript.Echo(iterator.Current());

}

while(iterator.Next());

 

}

}

function TestLinkedList()

{

var list = new LinkedList();

list.Add(15);

list.Add(“Hello, World!”);

WScript.Echo(list.Length());

DisplayList(list);

WScript.Echo(“—“);

list.InsertAt(1, new Date());

DisplayList(list);

WScript.Echo(“—“);

list.RemoveAt(2);

DisplayList(list);

WScript.Echo(“—“);

}

TestLinkedList();

If you need a refresher on linked lists and their variants, Wikipedia has a good write-up that I won’t repeat here.

In case anyone in Lake County, Illinois/Kenosha County, Wisconsin reads this blog, I’d like you all to know that the LCNUG group is already gaining momentum. To give some people an idea of how fast things can move, I’d like to take some time to explain what is going on. I’ll post (when I remember to do so) about what is going on with the group and how we are doing as we go through our gestational phase.

The first thing I did was pick a ‘dream venue’. In this case, I wanted a local location with great parking, centrally located, and with space to host a largish group. The local community college was my first choice. I sent a message to the head of the CLC Computer department who put me in contact with their .NET instructor, John North. John and I talked about what a .NET User Group is, when they meet, etc. He then worked with his department and got us a location. CLC has a charter that includes working with the community. His department used this reasoning to get approval for the LCNUG to meet on the last Thursday of the month for every month except November and December (dates are November 20 and December 18 in these cases). Once this was done, I set out to contact the local developer community so that we could have some attendees at our first meeting.

In the process, I found out that another local programmer, Tim Stall, had just started meeting with his coworkers for the same reasons as me-driving to downtown Chicago or Downers Grove is a bit far for folks who work in Lake County. Tim and I found each other by contacting our local Developer and Architect Evangelist. At this point in time, that’s Dave Bost and Larry Clarkin. Dave and Larry made sure that Tim and I got on the same page. They also looped in Keith Franklin, who runs CNUG, so that we could get linked from their site. This all happened over the course of a few hours. I’ve also got people sending me messages and asking to help out.

Why do I bring this up? I thought that anyone else looking to start a .NET Users Group would be interested in finding out what does it look like from the time one says ‘we need a group in this area’ to actually getting a group together. I started the process when I contacted CLC on April 17, 2008. At this point, I’ve got the following things ‘done’:

• Scheduled a venue through the end of the year
• Contacted Microsoft
• Setup a web site
• Setup an account on CodeZone.
• Setup an account on INETA. FWIW, their ‘register a .NET user group’ form is busted. I’m looking for alternate ways to register. Fortunately, I have some avenues to investigate.
• Have some feelers out for sponsors.

Doing this isn’t too hard. Like I said, I’m also starting to get help from others. I don’t want this to be the ‘Scott Seely’ show. I want a group where I and other like me can learn and socialize.

I’ll let you know how everything works out.

I want to take a few moments to announce the formation of a .NET Users Group in Lake County, Illinois. Our first meeting will be at CLC in Grayslake, IL. I’ll be the inaugural speaker giving a beginner level talk on Windows Workflow. For details, please visit www.lcnug.org. If you plan on attending, are interested in sponsoring, or have questions, feel free to contact me (scott at scottseely.com).

Today, I had to debug a strange problem. We have a web application that does some fancy printing. The main application server is a Unix machine, the print component lives on Windows. The network between these two has all sorts of fun firewall rules that HTTP type requests can navigate so long as the proxy on the machine is setup correctly. Unfortunately, the Windows test box didn’t have the proxy setup correctly and I didn’t have easy access to the one account that runs the service. To make the proxy set for all users, I had to ask my good friend, Google, how to do this. Google answered “Change the default connection policy for all users.” Google didn’t explain how to do this very nicely (what a jerk!).

I then thought that maybe Google didn’t have the whole answer in one place. (not a jerk!) So, I asked Google “How do I set the local policy on a Windows 2003 server?”

Google answered, “Start–>Run–>gpedit.msc”. Cool, gpedit.msc is the name of the Group Policy Editor and it is a Microsoft Management Console plugin (yeah, you can get all that info from the filename if you live in Windows long enough– I’ve in some sort of Microsoft DOS/Windows mode since 1984).

From there, I just figured things out. So that you too can benefit from my digging, here is the info:

1. Navigate to User Configuration–>Windows Settings–>Internet Explorer Maintenance–>Connection
2. Double click on ‘Proxy Settings’
3. Set your proxy.

These settings then get applied to all users, including those whose passwords you can’t recall:) For what it’s worth, this also works on Windows XP. I haven’t tried Vista, but I bet the results are the same there too.

I was checking out the ads for the local office supply and electronics stores during my lunch hour and I saw that Office Depot was selling the ViewSonic VX2235wm for $259– the same price as I paid for the hunk of junk Samsung. I plugged it in to my laptop and IT JUST WORKED! Everything is crisp, clear, perfect!

The installation experience went like this: I plugged in the monitor to power and my laptop. Vista asked me if I wanted the display on the left or right of my primary display (right) and then I was in business. This is NOT what happened this weekend with the Samsung.

So far, I’ve adjusted nothing on the monitor. I’m so HAPPY that this thing works. ViewSonic is just a better monitor manufacturer.

Florin Lazar has an interesting post on using C# 3.0 to make writing transaction blocks a little ‘pithier’. In ‘A Simpler TransactionScope‘, he suggests using a delegate and a lambda expression to accomplish his goals.

transacted(()=>
{
   using (SqlConnection connection = new SqlConnection(connectionString))
   {
      connection.Open();

      SqlCommand command1 = new SqlCommand(commandString1, connection);
      command1.ExecuteNonQuery();

      SqlCommand command2 = new SqlCommand(commandString2, connection);
      command2.ExecuteNonQuery();
   }
});

delegate void TransactedCodeDelegate();
void transacted(TransactedCodeDelegate txCode)
{
   using (TransactionScope ts = new TransactionScope())
   {
      txCode();
      ts.Complete();
   }
}

The thing that bothered me about this is, can’t I approach this using C# 2.0? And, yes, I can!

transacted(delegate()
{
   using (SqlConnection connection = new SqlConnection(connectionString))
   {
      connection.Open();

      SqlCommand command1 = new SqlCommand(commandString1, connection);
      command1.ExecuteNonQuery();

      SqlCommand command2 = new SqlCommand(commandString2, connection);
      command2.ExecuteNonQuery();
   }
});

In case you are missing the change, Florin suggests using ()=> (4 characters) and I suggest using delegate() (10 characters). Otherwise, these are identical. They both use an anonymous delegate to get the job done.

I’m not suggesting that Florin’s method is flawed. I’m just suggesting that folks who still use VS 2005 in their day to day job can pick up this trick without an upgrade.

Scott Hanselman put up a post showing some nifty LINQ code. I’ve been dabbling with it a little here and there, trying to see what it gave me. I like the new way of declaring member variables:

int _age;

public int Age

{

   get { return _age; }

   set { _age = value; }

}

is fairly verbose, and it doesn’t add any real value for readability. So, I’m a huge fan of this:

public int Age { get; set; }

which is identical in the eyes of the compiler, but way better for doing a code review.

I also like the vanishing need to add properties and appropriate constructors. I like being able to write

new Person(){Age = 11, Gender=Gender.Male, Name=“Vince”}

without needing to write something like this:

public Person(int age, Gender gender, string name)

I also like the simpler lambdas and other expressions. So, tonight I finally put together all the different basic features and had this running:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Collections;

namespace LinqStuff

{

  enum Gender

  {

    Male,

    Female

  }

class Person

{

   public int Age { get; set; }

   public Gender Gender { get; set; }

   public string Name { get; set; }

   public override string ToString()

   {

       return string.Format(“{0}: {1}: {2}”, Name, Age, Gender.ToString());

   }

}

class Program

{

   static void Main(string[] args)

   {

      var people = new List<Person>(new Person[] {

          new Person(){Age = 11, Gender=Gender.Male, Name=“Vince”},

          new Person(){Age = 6, Gender=Gender.Female, Name=“Angeline”},

          new Person(){Age = 5, Gender=Gender.Male, Name=“Phillip”}

      });

      var boys = from a in people where a.Gender == Gender.Male orderby a.Name select a;

      people.Add(new Person() { Age = 37, Gender = Gender.Female, Name = “Jean” });

      ListEm<Person>(boys);

      people.Add(new Person() { Age = 35, Gender = Gender.Male, Name = “Scott” });

      ListEm<Person>(boys);

}

stati
c void ListEm<T>(IEnumerable<T> vals)

{

      new List<T>(vals).ForEach(a => Console.Write(a.ToString() + “,”));

      Console.WriteLine();

}

}

}

The coolest thing here? My wife is learning C#. She took one look at the code and was able to instantly see that boys would automatically update as the people collection changed. The syntax passes the ‘is it instantly grokkable’ test for my sample audience of 1. I do like the fact that this syntax does focus more on what I want done instead of having to prescribe how to do it.