For truly top-notch Agile .NET training, please investigate Headspring's Agile Boot Camp™ for .NET Part I. See http://www.headspringsystems.com/services/agile-training/agile-boot-camp-part-I/ for details. I have taken the class myself and I highly recommend it.

I'm glad to be a part of Headspring, an impressive, Austin-based company offering software development outsourcing and agile training.

Headspring is offering an "encore performance" of our workshop on Inversion of Control. On January 19th, Matt Hinze will present anew his "Decoupling Layers using Inversion of Control" training at Austin's Microsoft Technology Center. Follow the link to register: http://www.headspringsystems.com/community/workshop/

A deep dive into IoC and dependency injection will be offered on December 15th, 2009 in Austin, Texas at the Microsoft Technology Center. Register here: http://www.headspringsystems.com/community/workshop/

The following will be detailed:

• Inversion of Control
  • A concept
  • Relinquishing the responsibility of managing dependencies
• Dependency Injection
  • A pattern
  • Constructor injection
  • Property injection
• Some Benefits Enumerated
  • Testing: Makes it easy to isolate classes under test and to test interactions between classes by allowing the tester to provide a special implementation
  • Reuse: Enables code reuse and prevents duplication by enabling the sharing of functional parts
  • Simplicity: Since each component is only concerned with its responsibility, it can focus on that simple job
  • Construction velocity: Speed is quickened because of the above things. That's what we're here for, right?

The training starts at 2:00 P.M.

XAMLExport is not the proper name for Mike Swanson's tool. See: http://www.mikeswanson.com/xamlexport/

While I had two classes in college on HTML, I didn't really start producing sophisticated HTML until I was exposed to Macromedia Dreamweaver. With Dreamweaver's easy, GUI-based means of laying out tables, my game got better, and, years later, when it came to pass that tableless design was to replace table-based design as the in vogue, industry standard for laying out web pages, I had progressively learned enough HTML to be able to step away from the WYSIWYG crutch of Dreamweaver and venture into the waters of CSS without a comparable crutch. That said, Dreamweaver got me to where I am presently. I needed the crutch initially.

Presently, I'm learning a little XAML, and I am again finding the value in a WYSIWYG crutch. I found a means to design in Adobe Illustrator (which I have used for over a decade and am very comfortable with) and then export from Illustrator to XAML. I use and recommend Mike Swanson's XAMLExport which may be had at here: http://www.mikeswanson.com/XAMLExport

Here is an example of producing XAML with XAMLExport in sixteen steps.

One. To begin with I create a new Illustrator file and first consider what size I want the whole of the Silverlight movie I am to create to be. I decide I want my movie to by 300 pixels in width and 200 pixels in height. To prepare for this in Illustrator I'm going to make a rectangle which will serve as a background for the entire movie. To be sure the rectangle exports at the appropriate pixel dimensions, I: First, select the rectangle tool from the toolbar, and second click to create a rectangle instead of dragging out a rectangle freehand. In clicking, a dialog box appears requesting dimensions for the rectangle. I give 300 points for the width and 200 points for the height. When my Illustrator file is exported to XAML, point values will be cast to pixel values.

Two. My rectangle is created.

Three. Next I create a new layer in Illustrator and lay out some vector shapes on it. The image of the sun shown here would be a pain to write in XAML, but hours of work have become seconds of work with the help of Illustrator. (I'm building in Illustrator instead of Expression Blend as I'm already strong in Illustrator.)

Four. I want to add an image to my Silverlight movie. Unfortunately, there is no way to carry an image over to XAML with XAMLExport so I will instead make a rectangle to serve as a placeholder for the image. Again, dimensions are important, so I make a new layer, select the rectangle tool, and then click to type numeric values for rectangle dimensions.

Five. A rectangle is made.

Six. I decide I want my background to have a gradient fill and I give it one. The gradient effect will carry over to the XAML. At this point, I am done with my Illustrator file. I select Export... under the File menu and then pick XAML for Silverlight (*.XAML) as the "Save as type" value at the dialog box which appears. I save out a file with a .xaml extension.

Seven. I close Illustrator and open Visual Studio. I create a Silverlight movie. I open the default MainPage.xaml file that is made at the movie's generation.

Eight. I copy the contents of the .xaml file I made in Illustrator into the Grid control at MainPage.xaml. Ideally, I could make the d:DesignWidth and d:DesignHeight values in the UserControl tag match the 300 x 200 dimensions of my content at this point too.

Nine. I preview my movie. It works! Everything is lovely... well, save for the missing image.

Ten. Within the XAML, I look for the box to replace with an image. Every separate layer I made in Illustrator became a different Canvas in the XAML generated (with notes to clarify which layer was which). The individual shapes I made in Illustrator were cast to Paths. I find the Canvas that corresponds to "Layer 3" where I built my placeholder rectangle.

Eleven. I make a new Canvas below the "Layer 3" Canvas and I put an Image in the new Canvas.

Twelve. I test anew. Looks like my Image hugs the upper left corner of the Canvas it is in.

Thirteen. I add a Margin parameter to my new Canvas.

Fourteen. How did I know what values to use for the Margin? A closer look at the Data parameter for my placeholder box reveals four vertices. I find the number pair for the upper left corner and use the pair for the first two values in my Margin parameter. (The second two values can simply be zeros as they are extraneous given that the image will hug the upper left corner of the Canvas.)

Fifteen. I remove the "Layer 3" Canvas as I no longer need my placeholder. (I only needed the placeholder box to set the Margin parameter at the Canvas holding my Image.)

Sixteen. I preview my movie once more. All is well.

Headspring Systems is growing nicely. The software firm is now a Microsoft Gold Certified Partner (see: http://www.headspringsystems.com/about/pressreleases/Default.aspx?id=8.20.09) and has won a slot on Inc. Magazine's Inc. 500 (see: http://www.headspringsystems.com/about/pressreleases/Default.aspx?id=8.12.09).

Headspring Systems is having a quarterly drawing and giving away an iPod to the drawing's winner! Get your name in the fish bowl before the end of September at http://www.headspringsystems.com/community/promotional/

In the time I've been at Headspring Systems I've watched the organization blossom into the premiere shop for custom application development statewide in Texas. Headspring is the fourth small business which I have been a part of, but the first to move beyond a dream of what might be to become an enviable enterprise, the best player in its space.

Perhaps the fourth time is the charm. Lauren Bacall was Humphrey Bogart's fourth wife after all.

I'll stop digressing :) - Kudos to everyone who made Headspring what it is today!

Headspring Systems is hosting a free, half-day deep dive into ASP.NET MVC in just five days time at the Microsoft Technology Center at 9606 North MoPac Expressway in Austin, Texas 78759 (i.e. the North Austin locale where the Austin .NET Users Group meets). Register for our event here.

Our adventures in custom application development have left us frustrated with the web forms means of crafting user interfaces, an archaic carryover from Visual Basic's environment, and especially at the fact that gobs of code that cannot be secured behind unit tests snowball into unwieldy messes in the code behinds. Fortunately, Microsoft's model-view-controller pattern now offers a superior alternative.

Obviously, there is going to be a bit of a learning curve involved in understanding a new way to approach web design for .NET, but perhaps we can make it less painful for you.

At 1 PM on Tuesday, June 16, 2009, Headspring's Jeffrey Palermo and Eric Hexter will offer their expertise on MVC and take questions. Look for their presentations to be comparable to those they gave at this year's Austin Code Camp and the presentations of our prior half-day free training on 2/19/2009. Again, register here to attend.

Most recently, I've been asked to work to boost SEO traffic to Headspring's own web site, and, in learning the ropes of site optimization (thank you Eric Hexter), I have gotten to write some copy for headspringsystems.com. Trying my hand at copy writing has been enjoyable and I'm pleased with a landing page at http://www.headspringsystems.com/services/agile-training/domain-driven-design-training.aspx that I wrote some verbiage for. I used some of my own life experience for this. There was a time in 2002 when I spent five months midyear as the "Cold Side Person" at one of Austin's more famous cheesesteak chains. I found the means of communicating orders by way of in-house notation... "challenging"

Headspring Systems is pleased to welcome Eric Anderson to our team. He is a valued addition to the core of developers spearheading one of our most prominent projects. To learn more about Eric, visit his blog at http://testinfected.blogspot.com/

What follows is what I hope to be a dumbed-down example of how to enact IoC (Inversion of Control) that anyone may easily follow. My example uses StructureMap. There are a great many tools that one may utilize for IoC. I'm using StructureMap as Headspring has standardized around StructureMap.

Alright, we will use an example Visual Studio 2008 C# web application with one web form (Default.aspx) and three classes. The function of the application is to firstly display a TextBox, a Button, and a Label, and secondly to put the number of characters in the TextBox into the Label whenever the Button is pressed. Thus, if I enter "123 Happy Street" into the TextBox and press the Button, I should see "11" appear in the Label.

So how does the web form translate a random string into a numeric count of particular characters? The code behind (Default.aspx.cs) looks like this:

using System;

namespace inversiontest
{
    public partial class _Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {

        }

        protected void Button1_Click(object sender, EventArgs e)
        {
            string myCopy = TextBox1.Text;
            NonLetterPurge myCutter = new NonLetterPurge();
            CharacterCount myCounter = new CharacterCount();
            StringHandler myHandler = new StringHandler();
            int letterCount = myHandler.runProcess(myCutter, myCounter, myCopy);
            Label1.Text = letterCount.ToString();
        }
    }
}

The three classes being used look like this:

NonLetterPurge.cs:

namespace inversiontest
{
    public class NonLetterPurge
    {
        public string dropUndesirableCharacters(string blobOfCopy)
        {
            string cleanBlob = "";
            foreach(char blobCharacter in blobOfCopy)
            {
                if (char.IsLetter(blobCharacter))
                {
                    cleanBlob = cleanBlob + blobCharacter;
                }
            }
            return cleanBlob;
        }
    }
}

CharacterCount.cs:

namespace inversiontest
{
    public class CharacterCount
    {
        public int convertStringToNumber(string blobOfCopy)
        {
            return blobOfCopy.Length;
        }
    }
}

StringHandler.cs:

namespace inversiontest
{
    public class StringHandler
    {
        public int runProcess(NonLetterPurge cutter, CharacterCount counter, string copy)
        {
            string revisedCopy = cutter.dropUndesirableCharacters(copy);
            return counter.convertStringToNumber(revisedCopy);
        }
    }
}

With the four pieces of C# above (one code behind and three classes), my application performs as it should. However, all of my classes are tightly coupled and I have to new up three classes just to use one.

The following details the introduction of Inversion of Control methodologies to the application described above.

First, I download the latest version of StructureMap (version 2.5.3) at http://sourceforge.net/project/showfiles.php?group_id=104740 and once I had the StructureMap.dll I placed it in my bin directory and then created a reference to it in my project within Visual Studio.

Secondly, I significantly rewrote my application. For each of the three classes I created an interface, and the classes themselves were altered as well (as was the way they were enacted from the web form's code behind). In the end there were seven files containing C# which were: CharacterCount.cs, Default.aspx.cs, ICharacterCount.cs (an interface for CharacterCount), INonLetterPurge.cs (an interface for NonLetterPurge), IStringHandler.cs (an interface for StringHandler), NonLetterPurge.cs, and StringHandler.cs. These items contained the following code:

CharacterCount.cs:

namespace inversiontest
{
    public class CharacterCount : ICharacterCount
    {
        public int convertStringToNumber(string blobOfCopy)
        {
            return blobOfCopy.Length;
        }
    }
}

Default.aspx.cs:

using System;
using StructureMap;

namespace inversiontest
{
    public partial class _Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            ObjectFactory.Initialize(x =>
            {
                x.ForRequestedType<ICharacterCount>().TheDefaultIsConcreteType<CharacterCount>();
                x.ForRequestedType<IStringHandler>().TheDefaultIsConcreteType<StringHandler>();
                x.ForRequestedType<INonLetterPurge>().TheDefaultIsConcreteType<NonLetterPurge>();
            });
        }

        protected void Button1_Click(object sender, EventArgs e)
        {
            string myCopy = TextBox1.Text;
            var myHandler = ObjectFactory.GetInstance();
            int myNumber = myHandler.runProcess(myCopy);
            Label1.Text = myNumber.ToString();
        }
    }
}

ICharacterCount.cs:

namespace inversiontest
{
    public interface ICharacterCount
    {
        int convertStringToNumber(string blobOfCopy);
    }
}

INonLetterPurge.cs:

namespace inversiontest
{
    public interface INonLetterPurge
    {
        string dropUndesirableCharacters(string blobOfCopy);
    }
}

IStringHandler.cs:

namespace inversiontest
{
    public interface IStringHandler
    {
        int runProcess(string copy);
    }
}

NonLetterPurge.cs:

namespace inversiontest
{
    public class NonLetterPurge : INonLetterPurge
    {
        public string dropUndesirableCharacters(string blobOfCopy)
        {
            string cleanBlob = "";
            foreach(char blobCharacter in blobOfCopy)
            {
                if (char.IsLetter(blobCharacter))
                {
                    cleanBlob = cleanBlob + blobCharacter;
                }
            }
            return cleanBlob;
        }
    }
}

StringHandler.cs

namespace inversiontest
{
    public class StringHandler : IStringHandler
    {
        private readonly ICharacterCount _characterCount;
        private readonly INonLetterPurge _nonLetterPurge;

        public StringHandler(ICharacterCount characterCount, INonLetterPurge nonLetterPurge)
        {
            _characterCount = characterCount;
            _nonLetterPurge = nonLetterPurge;
        }
        
        public int runProcess(string copy)
        {
            string revisedCopy = _nonLetterPurge.dropUndesirableCharacters(copy);
            return _characterCount.convertStringToNumber(revisedCopy);
        }
    }
}

The application now runs and works as it did before, but much has changed behind the scenes. Notice that the code that runs when the button is clicked which once read...

string myCopy = TextBox1.Text;
NonLetterPurge myCutter = new NonLetterPurge();
CharacterCount myCounter = new CharacterCount();
StringHandler myHandler = new StringHandler();
int letterCount = myHandler.runProcess(myCutter, myCounter, myCopy);
Label1.Text = letterCount.ToString();

...has been simplified to:

      
string myCopy = TextBox1.Text;
var myHandler = ObjectFactory.GetInstance();
int myNumber = myHandler.runProcess(myCopy);
Label1.Text = myNumber.ToString();

The copy in the Page Load event wires up the interfaces in preparation of their use. It looks like so:

            ObjectFactory.Initialize(x =>
            {
                x.ForRequestedType<ICharacterCount>().TheDefaultIsConcreteType<CharacterCount>();
                x.ForRequestedType<IStringHandler>().TheDefaultIsConcreteType<StringHandler>();
                x.ForRequestedType<INonLetterPurge>().TheDefaultIsConcreteType<NonLetterPurge>();
            });

Obviously, it would be ideal to not have to repeat this manner of wiring across the Page Load events of many web forms in a more complicated application. Couldn't these sorts of associations just be enacted once globally at the launch of an application? Yes, if I remove the lines of code above, I can enact the same effect by creating an XML configuration file called StructureMap.config. In this file I will have the following:

<StructureMap>

<PluginFamily Type="inversiontest.ICharacterCount" Assembly="inversiontest" DefaultKey="Default">
<Plugin Assembly="inversiontest" Type="inversiontest.CharacterCount" ConcreteKey="Default" />
</PluginFamily>

<PluginFamily Type="inversiontest.INonLetterPurge" Assembly="inversiontest" DefaultKey="Default">
<Plugin Assembly="inversiontest" Type="inversiontest.NonLetterPurge" ConcreteKey="Default" />
</PluginFamily>

<PluginFamily Type="inversiontest.IStringHandler" Assembly="inversiontest" DefaultKey="Default">
<Plugin Assembly="inversiontest" Type="inversiontest.StringHandler" ConcreteKey="Default" />
</PluginFamily>

</StructureMap>

Headspring Systems has refined its web presence to reflect the company's standing as a premiere Agile software development/training/coaching firm. Headspring invites you to tour the enterprise at http://www.headspringsystems.com/ and hopes to illuminate a better way to undertake software engagements.

Strictly speaking, the Tarantino Project is a grab bag of useful .dll files for technologies such as NHibernate and StructureMap which are conveniently collected in one place (http://code.google.com/p/tarantino/) and which may be used in a .NET application.

That said, it is fairly safe to predict that a Tarantino application will be established in an onion architecture in which a given solution will have separate projects for Core, Core.IntegrationTests, Core.UnitTests, Database, Infrastructure, Infrastructure.IntegrationTests, Infrastructure.UnitTests, UI, and, perhaps, UI.Controls. It took me a little while to truly feel comfortable in an onion environment and to understand how all of the Tarantino tools come into play. Now that I "get it" however, I am sold.

For others who find their eyes tearing at cutting their first Tarantino onion I offer this suggestion: Set up a dummy Tarantino application and create an object. You will feel much better once you have done so.

Recently, I worked on a web site which sends email notifications whenever a visitor completes a web form. I thought it might be wise to record the data involved for each sending to a database. What follows, are the steps I undertook to do so. I feel this scenario illustrates fairly well how to create a Tarantino object.

1. 
   

   The first step I undertook was to decide on a name for my object. I chose "OutgoingEmailAttempt." In an Agile setting the name should match the term the customers use for the correlating concept so that there is no translation needed between terms discussed aloud and terms nested in code (where the name of the object will appear in all of the file and class names associated with the object, to ensure logical designations which are not painful for anyone to understand).

   
   

   With a name in mind, I then created a database table that was also called "OutgoingEmailAttempt" in Microsoft SQL Server Management Studio Express. I was careful to use the "Generate Change Script" feature to save the SQL from the table creation, and within my Tarantino application, I put the .sql file in the Database project within the "Update" folder.

   
   

   Why is it important to retain the SQL scripts? If one has a record of the SQL scripts used to create a schema, one may thus recreate the schema elsewhere. Tarantino applications typically employ multiple instances of their database schemas. There will be a separate database running in each individual developer's work environment, a separate database in a staging environment, a separate database in the production environment, etc. It is common to have a database table devoted to a list of scripts which have already been run and a build process in which scripts which are newly introduced get run before being logged to the table themselves. By way of this configuration, when the SQL for creating a database table for an object is checked into the code repository, the table will soon exist at each individual developer's work environment, a separate database in a staging environment, a separate database in the production environment, etc.

   
   

   The columns in my "OutgoingEmailAttempt" table each corresponded to a property for the "OutgoingEmailAttempt" object. I created varchar data type columns named NameOfParty (who completes a web form), EmailAddressOfParty, PhoneNumberOfParty, CommentsOfParty, IpAddressOfParty, InHouseNotation (for denoting why the email alert was sent), and InHouseEmailAddress (which clarifies which address the email alert was sent to). In the schema design: The columns should have the same names the object properties will ultimately have and the names should make sense. I also made a datetime data type column called ContactTime, and, most importantly, I made a uniqueidentifier data type column dubbed OutgoingEmailAttemptId. In every Tarantino application I've yet seen, the name of the uniqueidentifier column must be: the name of the object + "Id"

   
   
   





2. 
   

   The second file made was a class for the object itself titled "OutgoingEmailAttempt.cs" in the Core project under the "Model" folder. An object class such as this one should be made largely void of code so that a test for the class may be written before the real guts of the class are fleshed out. Try to write a class just complete enough to be referenced by a test and still compile without throwing an error.

   
   
   



3. 
   

   The third file is "OutgoingEmailAttemptTester.cs" in the Core.UnitTests project under the "Model" folder.

   
   

   The tester class may entail numerous unit tests. For any one test, the first driver in ping pong pairing must refine the object class in question enough to make a test against it fail without throwing an error and must also refine the test itself enough to end with a failing test which is strong, while the second driver is charged with making the test past. The pairing partners should work back and forth in this manner to write as many tests as are needed.

   
   

   Things which one should obviously add to an object class and test against are property accessors. In my class I wrote property accessors for NameOfParty, EmailAddressOfParty, PhoneNumberOfParty, CommentsOfParty, IpAddressOfParty, InHouseNotation, InHouseEmailAddress, and ContactTime. I used names identical to names given for corresponding columns at the database schema. I made InHouseEmailAddress a string variable, ContactTime a DateTime variable, and so on. I did not write a property accessor for OutgoingEmailAttemptId because my OutgoingEmailAttemptTester.cs class inherits from another class, PersistentObject.cs, which manages the "Id" accessor and a few other things common to all objects which inherit from it.

   
   
   



4. 
   

   The next step was to create a NHibernate mapping file to allow the Tarantino application to interact with the database table which was just created. I made OutgoingEmailAttempt.hbm.xml in the Infrastructure project within the "Mappings" folder (which, in turn, sits in the "DataAccess" folder). When undertaking such a process, it is best not to focus on getting the mappings accurate initially, but rather to just set up a placeholder file. The accuracy will be hammered out in the next step.

   
   

   It is crucial to set the "Build Action" property of an .hbm.xml file to "Embedded Resource" instead of the default value of "Compile." This may be done by right-clicking on the file in the Solution Explorer within Visual Studio and selecting "Properties" from the menu which appears.

   
   
   



5. 
   

   The fifth file I created was an integration test class called "OutgoingEmailAttemptMappingsTester.cs" in the Infrastructure.IntegrationTests project within the "Mappings" folder (which, in turn, sits in the "DataAccess" folder). Upon the successful completion of a run of a mappings test to add an entry, one should be able to see a row created at the corresponding database table. Obviously, if the mappings are inaccurate in the .hbm.xml file, the mappings test will fail when run and the .hbm.xml file will have to be refined in order to make the test pass.

   
   

   When undertaking ping pong pairing, one developer, the driver, will write, first, a hollow .hbm.xml file and, secondly, a mappings test which cannot pass (due to the emptiness of the file it tests), while the driver's partner, the navigator, will observe and speak aloud thoughts and suggestions. Once the driver and the navigator agree that the test is solid, then the two developers switch roles. The navigator becomes the driver and refines the .hbm.xml so that it will pass the mappings test, while the previous driver becomes the new navigator and offers verbal direction and a critical eye.

   
   

   I'm not going to dive into specific syntax for C# (the language used in Headspring Systems' Tarantino applications) or NHibernate in this article, but I also don't really have to. When creating the files for a new Tarantino object one can easily gauge a sense of what needs to be written by looking at the corresponding files for other objects in either the same solution or another Tarantino application. When in doubt, look to the existing work of others for guidance.

   
   
   



6. 
   

   In the Infrastructure project, I created "OutgoingEmailAttemptRepository.cs" within the "Repositories" folder (which, in turn, sits in the "DataAccess" folder). Repository classes, facilitate the casting of database data to objects and likewise the pushing of object data to databases.

   
   
   



7. 
   

   In the Infrastructure.UnitTests project, I created "OutgoingEmailAttemptRepositoryTester.cs" within the "Repositories" folder (which, in turn, sits in the "DataAccess" folder). As you might imagine, this class tests my repository class. At this point in the article, you may also be able to imagine how two programmers may write both a repository class and the unit tests to test it by way of ping pong programming.

   
   
   



8. 
   

   The last files I made were some web pages in the UI to use my new OutgoingEmailAttempt object and one interface.

   
   

   My Tarantino application is set up so that the UI project references both the Core and Infrastructure projects and the Infrastructure project references the Core project. So then, how may "OutgoingEmailAttempt.cs" utilize "OutgoingEmailAttemptRepository.cs" for database integration? The answer is by way of StructureMap and the creation of an interface within the Core project. I made "IOutgoingEmailAttemptRepository.cs" within the "Repositories" folder which sits within the "Model" folder within the Core project.

   
   

   "OutgoingEmailAttemptRepository.cs" was made to inherit from "IOutgoingEmailAttemptRepository.cs" and both files reference StructureMap in their using statements.

   
   
   

Conclusion: The steps above detail the sum of what needed to be done in establishing an object in a Tarantino application. Outside of the UI files I made to actually use the object I created, I needed to create the eight files I've detailed. The steps are well worth taking. I feel this is a much better approach to writing a .NET application than making a few god classes in the App_Code folder. ;)

Hello, my name is Tom Jaeschke and I am paradoxically both the senior employee of and the most junior developer at Headspring Systems. As almost everyone at the organization has a blog, I thought that it would only be appropriate if I tried to start a blog myself, so here it is. I cannot offer any unique tips and tricks on .NET practices that my colleagues haven't already done a better job of outlining in their blogs, so I’m not yet sure what form my own blog will take.

I would like to say that I am honored deeply to work at the same company as Nicholas Becker, Jimmy Bogard, Blake Caraway, Eric Hexter, Matt Hinze, Kevin Hurwitz, Ken Jackson, Jeffrey Palermo, and Jeff Wilson. I am amazed at my fortune, as I could never have imagined a finer team to be associated with.

If you have not heard these names yet, please allow me to make the introduction. The following pictures were taken with my iPhone at a developers meeting over lunch on October 10, 2008. As you can tell, the pictures were not staged or planned. :)

In closing this entry, I would like to say, that, more than any other reason I could point to, Headspring's owner, Dustin Wells, is the number one reason why I, or anyone else, should be happy to work at Headspring. I've had some really bad bosses, but he is not one of them. He is the best boss I will ever have. Kudos to you Dustin!

I can recall the humble beginnings of Headspring before Nicholas Becker, Jimmy Bogard, Blake Caraway, Eric Hexter, Matt Hinze, Kevin Hurwitz, Ken Jackson, Jeffrey Palermo, and Jeff Wilson and I could not be happier for Dustin for the excellent team he has grown in the three years I have been working for him.

To learn more about me, please visit my web site at tomjaeschke.com

I'd like to welcome two new hires to Headspring Systems, a Mr. Blake Caraway (now a Senior Consultant) and a Mr. Duane DeRouen (now our Vice-President of Client Services). Both gentlemen were working in vital roles as contractors within Headspring's team at Dell, but now have been hired on direct with Headspring as of July 2008. Congratulations to both.