I needed to run some exploratory testing of a web application using FireFox on a Linux OS. In my environment, using anything but a Window's OS requires permission and several hoops through which to jump. I find myself using Hyper-V to avoid these issues, and because it is so easy.

There are so many versions of Linux, so which one should I choose?

I feel like a kid in a candy store when it comes to selecting one, or maybe two operating systems. I began with Ubuntu, essentially, picking up from the last chapter where I grew tired and put down the book that is Linux. Ubuntu worked well, or at least, it did not leave a bad taste in my mouth. Last time I installed Ubuntu, I was using Virtual PC 2004, and it worked successfully.

Installing Ubuntu 8.10 in Hyper-V was incredibly easy. A full installation required 3-4 screens of user interaction. After downloading the ISO image to my server, I fired it up in Hyper-V. First, select a language. Second, choose to try, install, check for defects, test memory, ect. I chose to "install" versus "try" a live version. Third, user input screen, answer some install configuration questions such as language, time zone, keyboard layout, disk space partition, and login information. Finally, after installing, I am prompted for my login and password. Total time was less than thirty minutes, and perhaps it could have been faster, but I was multitasking. After installing Ubuntu and configuring FireFox to work with my network, I was testing my web application.

Still in awe of how easy the installation was, I decided to try out other flavors of Linux. Like Microbrews, Linux distros seem to be a dime-a-dozen. I found some online articles to help me narrow down what distros other seems to like, and so I arrived at the following.

The distros I downloaded and installed (or tried to install) as a Hyper-V Virtual Machine.

• Ubuntu 8.10
• Fedora 10
• Linux Mint 6
• Mandriva Linux One 2009 (Gnome and KDE) - tried both
• Open SuSe 11.1 KDE
• SimplyMEPIS 7.0

In Hyper-V, installing Fedora, Linux Mint, and Open Suse were strait-forward and successful on my first run, just like Ubuntu. I had trouble with Mandriva and SimplyMEPIS. Both of them would hang as they tried to load the ISO image, so I gave up. At this point, I have four working Linux VMs enabling me to test my web applications, so the incentive to get Mandriva and SimplyMEPIS working just is not there right now. I do believe Mandriva and SimplyMEPIS will work with Hyper-V. I must have some configurations incorrect.

One thing I thought was funny about SimplyMEPIS is their website poses a question as part of their advertising, "Why SimplyMEPIS?" They respond with, "SimplyMEPIS just works!" It is sad that to have to advertise that "it just works," because to me, that implies the inverse was the rule rather than the exception with previous versions, or with the technology - in this case, Linux.

I have fought Linux installs in the past, getting my onboard sound card to work, locating other device drivers, and even upgrading browsers. When I see, "it simply works," I am still skeptical. It is unfortunate in my case with Hyper-V, that SimplyMEPIS did not work within the time limits I cared to allow for each distro. I will give it and Mandriva a fair shake by trying other configurations to get them working.

From my experiences, virtual machines are a great place to start getting familiar with operating systems. Having access to Hyper-V certainly made this experience successful and enjoyable. VMware and Virtual PC are two other virtualization software applications I have used as well for similar situations. VMware's support for Linux operation systems is great. I have been able to install Fedora Core and Ubuntu in Virtual PC, but not without swearing at my screen.

This is an interesting webcast on Channel9 where Eric Schmidt provides a technical tour of the NBCOlympics.com site built with Silverlight. If you are like me and become frustrated with the limited options of events the stations choose to broadcast, then we are in luck. The video that the NBCOlympics.com site is providing is excellent and covers nearly all the sports. I have heard estimates of roughly 2,200 hours of video, live commentary, live events, and with the ability to choose what we prefer to view. For those events we miss, we can search and view them at our leisure.

I have been able to watch some events I have always wanted to see but the television stations do not televise. Popularity and advertising dollars demand that stations air the usual suspects, swimming, track and field, gymnastics, ect. I have been able to explore fencing, sailing, handball, archery, and weightlifting to name a few.

If interested, check it out. If you have not seen the U.S. Men's 4x100 freestyle relay, check it out. What a race!

I was in a design discussion today and mentioned the need for a singleton object in our solution. Further along in the discussion I was trying to find a word that describes the opposite of a singleton, but alas, I struggled to find a word that may or may not exist. I just referred to the inverse object as a "new object." As I pondered this later in the day, I considered adjectives describing the nature of objects. They can be many things, but two concepts that popped into my head to classify them were "complex" and "simple."

I started playing with the words and making them resemble singleton. "Complexton" did not sound right to me. I should mention that I was washing my hands as I was contemplating this. I lifted up my head, looked into the mirror, and thought, "SIMPLETON." The opposite of a singleton is a "simpleton."

If the opposite of a singleton is not a "simpleton," then what is it? Until I find a plausible answer, I will try and insert this new term into my next design discussion.

Duplicate code to me is wrong. Writing duplicate code to me is like using poor grammar. If I am unaware of it, I am none the wiser. However, if I knowingly use poor grammar or duplicate code, I feel bad.

After seeing too many duplications across methods in one or more classes, I decided to investigate a way to remove these. I am always looking to remove duplicate code, even code that shares similarities, I look to refator. Removing duplications is important to adapt more easily to change. When a code change is required, we should only have to make it in one place. The following article will show two relatively simple means to address this code smell, delegates and an Aspect-Oriented approach.

The example I am using in this article is seen below. It is a unit test class, StackFixture class, and it is extremely trivial. This is a typical unit test taken from Test-Driven Development in Microsoft .NET. I have added the logging functionality as an easy means to show how these types of DRY violations can occur. While the duplications in this example deal with logging, they could pertain to other, more complex, functionality as well. The approaches to removing duplications across methods in this article can work with these simple scenarios, as well as more complex ones.

Take for example this sample test case. Each test method logs a message before and after executing the test logic. This violates DRY. We want to keep our test logic in our method, but factor out the duplicate logging. Again, if we were not logging, but doing some repetitive logic, we could factor that out as well.

   1: [TestFixture]

   2: public class StackFixture : AbstractBaseFixture

   3: {

   4:     private Stack stack;

   5:  

   6:     [SetUp]

   7:     public void SetUp()

   8:     {

   9:         stack = new Stack();

  10:     }

  11:  

  12:     [Test]

  13:     public void Empty()

  14:     {

  15:         Log.Info("Starting Empty test");

  16:  

  17:         Assert.IsTrue(stack.IsEmpty);

  18:  

  19:         Log.Info("Ending Empty test");

  20:     }

  21:  

  22:     [Test]

  23:     public void PushOne()

  24:     {

  25:         Log.Info("Starting PushOne test");

  26:  

  27:         stack.Push("first element");

  28:         Assert.IsFalse(stack.IsEmpty, "After Push, IsEmpty should be false.");

  29:  

  30:         Log.Info("Ending PushOne test");

  31:     }

  32:  

  33:     [Test]

  34:     public void Pop()

  35:     {

  36:         Log.Info("Starting Pop test");

  37:  

  38:         stack.Push("first element");

  39:         stack.Pop();

  40:         Assert.IsTrue(stack.IsEmpty, "After Push - Pop, IsEmpty should be true.");

  41:  

  42:         Log.Info("Ending Pop test");

  43:     }

  44:  

  45:     [Test]

  46:     [ExpectedException(typeof(InvalidOperationException))]

  47:     public void PopEmptyStack()

  48:     {

  49:         Log.Info("Starting PopEmptyStack test");

  50:  

  51:         stack.Pop();

  52:  

  53:         Log.Info("Ending PopEmptyStack test");

  54:     }

  55: }

Remove Duplications with Delegates

Quite simply, we can remove our method duplications using a delegate, in this case, the System.Action delegate. Thanks to Ayende for helping me understand this option. We create a method, TestMethod (as shown below), and add it to our StackFixture class. The method takes two strings (string beforeMessage and string afterMessage) and the Action delegate, representing the test method logic. We will call this method within our test cases.

   1: public void TestMethod(string beforeMessage, string afterMessage, Action action)

   2: {

   3:     // before

   4:     Log.Info(beforeMessage);

   5:     

   6:     // invoke our method

   7:     action();

   8:     

   9:     // after

  10:     Log.Info(afterMessage);

  11: }

Then, in our tests, we replace the following test method...

   1: [Test]

   2: public void Pop()

   3: {

   4:     Log.Info("Starting Pop test");

   5:  

   6:     stack.Push("first element");

   7:     stack.Pop();

   8:     Assert.IsTrue(stack.IsEmpty, "After Push - Pop, IsEmpty should be true.");

   9:  

  10:     Log.Info("Ending Pop test");

  11: }

With the same method using our delegate approach.

   1: [Test]

   2: public void Pop()

   3: {

   4:     TestMethod("Starting Pop test", "Ending Pop test",

   5:                delegate

   6:                    {

   7:                        stack.Push("first element");

   8:                        stack.Pop();

   9:                        Assert.IsTrue(stack.IsEmpty, "After Push - Pop, IsEmpty should be true.");

  10:                    });

  11: }

We can replace each of our test methods with the same TestMethod using the System.Action delegate. It will then easy to omit our before and after strings replacing them with "action.Method.Name," or some other intelligent logic to determine what to log.

This approach works well, but delegates are often difficult to understand. If this solution suits your needs, make sure the implementation is easily maintainable. What is nice about this approach is how simple it is. There is no need to reference any assemblies outside of the .Net framework, i.e. no third party dependencies.

The Aspect-Oriented Approach

Aspect-Oriented Programming (AOP) is an entirely different animal. It certainly deserves more than just a blog post. Please read more about it online. This article will not explain the details of AOP.

If you are reading this, welcome back. I will assume you are now familiar with AOP. There are several options for AOP frameworks. Some frameworks I have used are Spring.net, Castle Project, and PostSharp. The former two provide IoC capabilities as well. I suggest using a well-supported framework, one with community support and frequent updates. Investigate for yourself, there are several nice options available.

AOP with Castle DynamicProxy

Hamilton Verissimo put together a good sample using Castle's DynamicProxy. It is a nice, clean implementation.This worked fine for me and would work well in other situations. However, in my scenario, if I were to use this approach, I needed to have each of my test classes extend from MarshalByRef. In addition, I would need to modify the underlying NUnit framework to create my proxies in order to provide advice. Since I could not do the latter, or did not want to investigate, I searched for other AOP options.

The DynamicProxy aproach to solving your AOP needs is a great option. It just did not work in my situation, only because NUnit executes each of my methods. I would need to somehow intercept the creation of my test class, create a proxy of it, and execute the test methods on it.

AOP with PostSharp

Gael Fraiteur's PostSharp is a great option for AOP needs. It is extremely clean and easy to use. It is the simplest AOP framework I have used. I suggest watching Gael's video tutorial.

The first thing I needed to do, besides downloading and installing PostSharp, is to add two references to my project, PostSharp.Laos and PostSharp.Public. After that, I create a simple class extending OnMethodInvocationAspect, called LoggingMethodInvocationAspect.

   1: [Serializable]

   2: public sealed class LoggingMethodInvocationAspect : OnMethodInvocationAspect

   3: {

   4:     private ILogger log;

   5:  

   6:     public LoggingMethodInvocationAspect(ILogger logger)

   7:     {

   8:         log = logger;

   9:     {

  10:  

  11:     public override void OnInvocation(MethodInvocationEventArgs eventArgs)

  12:     {

  13:         // before

  14:         log.Info("OnInvocation Before proceed");

  15:  

  16:         // invoke

  17:         eventArgs.Proceed();

  18:  

  19:         // after

  20:         log.Info("OnInvocation After proceed");

  21:     }

  22: }

At this point, all we need to do is apply our aspect on target methods. The "AttributeTargetMembers" attribute can use wildcards. This tells the AOP framework to only intercept those methods in the "MathService" class that start with "Test." Below is the sample where I specify the target assembly, target type (class or classes to intercept), and target methods to intercept. There are many features beyond what I am showing so do further investigation.

   1: [assembly: ClassLibrary.SampleInterfaces.LoggingMethodInvocationAspect(

   2:     AttributeTargetAssemblies = "ClassLibrary.UnitTesting.Sandbox",

   3:     AttributeTargetTypes = "ClassLibrary.UnitTesting.Sandbox.MathService", 

   4:     AttributeTargetMembers = "Test*")]

Finally, my StackFixture class now looks something like this. Notice that the duplicate logging logic is now removed and each test method is prefixed with "Test" in the method name. This is so that PostSharp can filter what methods to intercept.

   1: [assembly: ClassLibrary.SampleInterfaces.LoggingMethodInvocationAspect(

   2:   AttributeTargetAssemblies = "ClassLibrary.UnitTesting.Sandbox",

   3:   AttributeTargetTypes = "ClassLibrary.UnitTesting.Sandbox.MathService", 

   4:   AttributeTargetMembers = "Test*")]

   5:     

   6: [TestFixture]

   7: public class StackFixture

   8: {

   9:     private Stack stack;

  10:  

  11:     [SetUp]

  12:     public void SetUp()

  13:     {

  14:         stack = new Stack();

  15:     }

  16:  

  17:     [TearDown]

  18:     public void TearDown(){}

  19:  

  20:     [Test]

  21:     public void TestEmpty()

  22:     { 

  23:         Assert.IsTrue(stack.IsEmpty); 

  24:     }

  25:  

  26:     [Test]

  27:     public void TestPushOne()

  28:     {

  29:         stack.Push("first element");

  30:         Assert.IsFalse(stack.IsEmpty, "After Push, IsEmpty should be false.");

  31:     }

  32:  

  33:     [Test]

  34:     public void TestPop()

  35:     {

  36:         stack.Push("first element");

  37:         stack.Pop();

  38:         Assert.IsTrue(stack.IsEmpty, "After Push - Pop, IsEmpty should be true.");

  39:     }

  40:  

  41:     [Test]

  42:     [ExpectedException(typeof(InvalidOperationException))]

  43:     public void TestPopEmptyStack()

  44:     {

  45:         stack.Pop();

  46:     }

  47: } 

The end result, a StackFixture test class with duplicate logging logic removed. The PostSharp AOP framework post-processes the compiled assembly and inserts itself, easily providing points of interception.

The PostSharp approach does involve a third-party dependency, but I feel like it is cleaner than the delegate approach. Gael informed me future versions of PostSharp will provide a more configurable solution than adding the [assembly ...] reference for the aspects, perhaps an XML configuration option. This can be done today, but involves some work.

Whether you use delegates, AOP, or some other approach, remove duplicate code wherever possible. I am happy to use either approach in my projects. There are tradeoffs to either solution, so investigate for yourself.

It is nice to be able to apply the Vista themes and sidebar personalizations (eye candy) to a Longhorn environment. This site appears to be thorough on the topic of Converting your Windows 2008 Server to a Workstation.

This article got me started with enabling the "aero" theme, Windows Server 2008 "Aero Enabled" Workstation Edition.

While installing Notepad2 on my Longhorn box (WindowsServer2008) I ran into an issue with overwriting the original notepad due to a lack of permissions. I found Matt Berther's article which helped me understand what files needed to be overwritten for use in Vista. While I ran into similar problems in Vista, I did not write down my steps, so when it came time to rebuild my Longhorn development environment, I battled the same issues.

Vista and Longhorn both have increased security measures.  Overwriting a system file like notepad.exe is more involved. While I can see their need for this added security, I do find it annoying. Regardless of whether or not you are installing Notepad2, as in this article, or you just need to reassign ownership of a file in Vista or Windows Server 2008, I hope this article helps alleviate some of the pain.

In following the article on overwriting notepad.exe with notepad2.exe, I first came across the issue of granting full control rights for this file to my logged in user. Since I have had to figure this process out more than once now, I am deciding to document it, with wonderful screen-shots.

While granting full control to the administrator, I was alerted with the following dialog.

In order to overwrite a file, like notepad.exe, we need to give the administrator "Full control." In order to do this, we need to change ownership of the file from "TrustedInstaller" to "Administrators." TrustedInstaller, by default, has full control, while the admin account does not.

Right click the target file, click Properties.

Click on the security tab. You should see the "Administrators" account, by default, with read and execute permissions only.

Click on the "Administrators" account, seen above, then click on "Advanced" as pictured below.

Next, we need to select the account for which we wish to edit owner permissions. Select the "Owner" tab. We should see "TrustedInstaller" highlighted as the current owner.

Click the "Edit..." button to change the owner of the file. The owner settings dialog should appear. Select the "Administrators" account, and click "Apply." After clicking apply, there should be a prompt as shown below.

Finally, click "OK." Then click "OK" to close the owner dialog. Click "OK" to save and exit the "Advanced Security Settings for <YourFileName.extension>."

Next, we want to allow "Full control" for the admin account. After closing the last dialog, we should still see the properties dialog for our file (the original dialog view, the second screen-shot in this series). Select the "Administrators" account, and click "Edit."

Give our "Administrators" account full control by enabling the checkboxes.

When you click "Apply" to apply these changes, the following prompt should be displayed. Click "Yes" to apply these changes to to grant full control to the administrator account.

At this point, the ownership of this file should have changed from the default "TrustedInstaller," to the "Administrators" group. For me, I can now overwrite this notepad.exe file with the more useful notepad2.exe.

I hope this article helps. Until Vista and Longhorn become second-nature, I know I will be referencing this.

The NHibernate FAQ
Craig Neuwirt
Hibernating Rhinos

I had to disable Internet Explorer Enhanced Security Configuration for my Windows2008 VMs today. I just couldn't take it anymore. I have been warned. I understand its importance. I am still turning it off. Don't try this at home.

I am currently working in a new development environment, unlike any that I have used in the past. It is different for two reasons, magnitude of dependencies and build process. The warning I have been given is, "this is a complex beast with lots of stuff in it, and much can go wrong." That statement pretty much covers the magnitude of dependencies stuff. As for the build process, my first question asked was, "you mean we don't use 'Ctrl+Shift+B' (in Visual Studio)?" No, we build using a command-line style approach, outside of the IDE.

Due the dependencies and build process, I wanted to schedule nightly builds on my local machines. This was when I discovered Windows PowerShell. PowerShell uses the .NET CLR and the .NET framework to provide new tools and methods for administering Windows environments. While similar in some aspects as DOS, PowerShell is much more. It is a command-line shell and scripting language that allows administrators to use C#.

Each night I want to backup certain files, sync files, clean and build my projects for 32 and 64 bit systems, update my environment with dependency changes, and email myself the log files generated during this process. I am not a DOS command nor scripting guru, but I could figure this out with some time. With PowerShell, I can leverage my C# knowledge to do all these tasks in a short amount of time.

If you want more control over administering your environments and would like to use C#, check out PowerShell. There is a good amount of support and tutorials to help get started.

Trivial Examples

The following is a trivial example of how to connect to a SQL database, query the Employees table of the Northwind database, and write those results to the screen. The PowerShell scripting syntax can be seen below.

   1: $conn = New-Object System.Data.SqlClient.SqlConnection

   2: $conn.ConnectionString = "Data Source=.;Database=Northwind;"

   3: $cmdText = "SELECT TOP 10 * FROM EMPLOYEES"

   4:  

   5: $conn.Open()

   6: $cmd = New-Object System.Data.SqlClient.SqlCommand($cmdText,$conn)

   7: $rdr = $cmd.ExecuteReader()

   8:  

   9: while($rdr.Read())

  10: {

  11:     $id = $rdr["EmployeeID"].ToString()

  12:     $fn = $rdr["FirstName"].ToString()

  13:     $ln = $rdr["LastName"].ToString()

  14:     Write-Host "$id $fn $ln"

  15: }

  16:  

  17: $conn.Close()

While that example is extremely trivial, it does show the power of using C# logic with the PowerShell language. It is easy to see how the code example above was translated from C# into PowerShell. The differences are syntactic.

For my nightly build scenario, I am able to create a scheduled task that calls a batch file, with similar contents as below.

   1: REM Calling Nightly Build

   2:  

   3: REM do the necessary to clean and build my environment

   4: call MyBuildLogicFile.bat

   5:  

   6: REM call powershell scripts

   7: powershell -command "& C:\PowerShellScripts\MyBuildScript.ps1

The batch file does the building then calls a PowerShell script I created to do help me parse my log files and email the contents. It actually call two scripts, one for parsing the content of my resulting log file, and the other to email the contents of the log file. The contents of the two files can be seen below.

PowerShell provides a number of predefined methods that can be used out of the box. Since I am interested in reading a log file, parsing its contents, and emailing the results, there are some functions available for making this scenario easier. For example, I do not need to recreate the wheel to read in a file's contents. I can use Get-Content. Before getting carried away with writing too much C#, check the available cmdlets (commandlets) to see if your desired functionality exists.

My file content parser script, using Get-Content.

   1: # Create a StringBuilder to retain our log file contents

   2: $sb = new-object System.Text.StringBuilder

   3:  

   4: # append a line break point, <br/> for the log file contents

   5: foreach ($line in get-content "C:\Output.log")

   6: {

   7:   $sb.Append($line).Append("<br/>")

   8: }

   9:  

  10: # Call our Emailer.ps1 to send this content to us

  11: powershell -command "& C:\PowerShellScripts\Emailer.ps1 -param '$sb'"

My email script that is called from the above code.

   1: param($param1) 

   2:  

   3: $message = new-object System.Net.Mail.MailMessage("me@mail.com", "me@mail.com")

   4: $message.IsBodyHtml = $True

   5: $message.Subject = "Automated Build Update"

   6: $message.Body += $param1;

   7:  

   8: $smtp = new-object Net.Mail.SmtpClient(”smtp.mail.com”, 587) 

   9: $smtp.EnableSsl = $True

  10: $smtp.Credentials = new-object System.Net.NetworkCredential("username", "password")

  11: $smtp.Send($message)

Pretty simple. Thanks to PowerShell, I have more control over administering my development and test environments using my preexisting knowledge of C#. One command that was always useful in Unix/Linux is grep. PowerShell uses Regex to simulate similar functionality, and you can find examples of those online.

I am using Internet Explorer 8 Beta right now after learning about the new features it provides beyond its previous version, IE7. I hate to admit this, but some time ago I gave up on using FireFox when it starting consuming nearly 100% of my CPU. This was happening all too frequently and I tried to resolve the issue using several approaches I found posted on blogs. After not having any luck, I started thinking, "why do I prefer FireFox over IE?"

What I liked about FireFox I could now install in IE7 with IE7Pro, an add-on for IE7 managed by a multi-national team, not a Microsoft affilate. FireFox does have a strong community creating and sharing browser niceties that make the web experience easier and more pleasant. Internet Explorer has this as well in the form of IE7 add-ons. At this point, I am happy with IE7 running IE7Pro. My browser experience is great, and when I absolutely need to use one of my FireFox extensions, I will start-up FireFox and run the extension, hopefully before it consumes my CPU.

Since I installed the latest version of Internet Explorer, IE8 Beta, FireFox is that much further from my mind. IE8 provides a number of built-in tools that make the browsing experience that much sweeter. For a web developer, the integrated developer tools are a must have, and for someone new to web developing, these tools will certainly shorten the learning curve. The JavaScript debugging capabilities are great. I am no longer dependent upon my Visual Studio IDE since a built-in IDE-like tool is provided for accessing and manipulating HTML, CSS, and JavaScript.

Another great feature is how Ajax navigation history is retained in IE8. This is perfect for mapping software where you constantly interact with the map by zooming in or out. The window.location.hash is set with a value to enable managing the page history. This is possible in previous versions of IE, but it requires some work, usually in the form of installing and configuring a framework to use with your site, something like the ReallySimpleHistory library.

I will spare you more details on IE8. I do encourage you to try it out for yourself. There are a number of other nice features not mentioned. IE8 integrates nicely with Live Writer, which makes posting easier.

After three years, I decided to finally update my blog engine to the latest version of DasBlog. What I have discovered over three years is that finding time to blog can be difficult, and finding time to maintain the blog site takes a backseat to blogging. Now that I have updated to the latest DasBlog, I inherit a number of nice security features to battle spam, as well as some cool usability features. Thanks to the DasBlog team for their efforts in creating this project, one of the few blog engines that does not require a database.

I have not spent much time skinning this site and I do not plan on it right now. I use the built in RSS capabilities of Microsoft Office Outlook for aggregating my feeds, so I rarely view the actual websites that I read. I am guessing that most readers use a similar approach, so with this in mind, my current site theme works for now.

What RSS readers are you using?

This is a nice example using the new ASP.NET MVC framework. It is a clone of the Digg site, so it shows some more practical functionality, well beyond "Hello World." Not that there are not other practical examples out there, but the site goes into good detail on the MVC framework.

When John Denver spoke about spring time, he spoke about he passing of winter. The green of the new leaves and of life going on. The promise of morning and the long days of summer. I am John Denver fan and obviously not afraid to admit it. What John failed to mention in any of his songs in regards to spring time is Code Camp, but John did not live long enough to experience this.

In recent years, the Code Camp movement is starting to become synonymous with spring time. The Boston .NET User Group has a code camp schedule that shows the various code camp events across the US, with most, if not all of them occurring during late winter and early spring. As I am looking through several camp's sessions, each seems to offer similar presentations on agile, MVC, Web Client Software Factory, and best practices, just to name a few. I think it is exciting to see the community support for these events in every city. I will be checking back with these sites to see how their support faired.

For me, it used to be the anticipation of a new baseball season that marked my spring, now its code camp. In Boise, spring and code camp both tends to come early. Code camp rejuvenates those desires to investigate new technologies that tend to become dormant during the winter.

Would John Denver have mentioned Code Camp in any of his songs? It is highly unlikely. However, he was an activist, caring for the environment and those who care for it. Code Camp involves a similar activism in the community. It is good to see it emerging.

Boise Code Camp 2008 was awesome. Thank you to David Starr and his wife, Eleanor, for taking ownership of this event and dedicating many months of their time to make this a reality. Thank you to the presenters for having the passion and desire to present technologies and practices, both new and not-as-new. Thank you to the many volunteers who put in countless hours to help coordinate the weekend's events. Thank you to the campers for attending and making this year's code camp a success.

I am sure everyone will be blogging about all the great sessions they attended at code camp. I enjoyed all of the presentations I attended, and I am excited to explore some new material.

I want to share a few thoughts on my presentation dealing with Model-View-Presenter in ASP.NET after listening to Scott Hanselman's session on the ASP.NET MVC Project. I may have the percentage incorrect, but Scott mentioned something like it is predicted that only 10% of the ASP.NET community currently using Web Forms will adopt and use the MVC framework. The MVC framework is an addition to ASP.NET, it is not a replacement. What this means is that Model-View-Presenter will still be a viable pattern to implement with your ASP.NET applications, and it is not going away. ASP.NET Web Forms will not be going away either.

Use MVP to get your third party controls under test. Use MVP to provide that separation of concerns in your legacy applications. Use it entirely or in conjunction with the MVC framework. It is all about testability. Glenn Block presented on the Web Client Software Factory, and what pattern does this implement? Model-View-Presenter.

I am providing my presentation and source code (3.67 MB) from my talk on MVP. It will be available via the Boise Code Camp site as well.

Again, thank the many individuals and their families who sacrificed their time to bring to the local community this years code camp.

Around the office's water cooler on Monday, I will be able to say, "and this one time, at code camp..."

The President ordered the Navy to shoot down a defunct U.S. spy satellite that could leak deadly toxic gas if its fuel tank reaches the Earth's atmosphere. The intercepting of the satellite was successful. It was successful thanks to a number of individuals, especially those engineers in the labs building and testing the systems used by the Navy.

Read More

My first job after graduating with my undergraduate degree was with Lockheed Martin located in Middle River, MD. I started as a test engineer then moved into development. The Lockheed Martin group where I worked was responsible for building the systems used on ships to launch missiles, known as the Vertical Launching System. The Lockheed Martin mentioned in the article linked above is responsible for the development of the "Aegis" combat systems used to detect and track targets, in this case, a satellite. Both systems appear to be integrated and working well together.

It is neat to think that those test cases we wrote for launching missiles are still working well. So many conditions needed to be checked for each launch that would make this article too lengthy. This just goes to show the importance of testing, on all levels.