new Christian(new Developer(new Man())).Thoughts;

AgileDotNet 2012

2012-01-23T21:24:00.003-06:00

My company, Improving, is hosting our third annual AgileDotNet conference in Dallas on Friday, February 17th. It will be a day of presentations and discussion focused on agile software development on the Microsoft stack, ALM tools, and the leadership and cultural issues involved in agile IT. Hope you can join us!

Full details can be found here.

Using Gists for Code Snippets

2011-12-26T14:42:00.001-06:00

Normally, I use Windows LiveWriter to write my blogs at BlogSpot. And I have always used syntax highlighter plug-ins to insert code snippets. These utilities in the past inserted a lot of html elements and style definitions in-line with the rest of the post or required setting up global stylesheets and javascript in order to work.

In the last few weeks, as I have been looking at transitioning my blog to a ruby-based engine called OctoPress, I found another mechanism for inserting code snippets - gists from GitHub. It allows you to store your code snippets online and easily add them to your posts with one line of code.

All you need to do is:

1. Go to http://gists.github.com

2. Sign up for a free GitHub account

All you have to do is click on the link in the upper, right-hand corner "Sign up for a GitHub account". It leads you through a process.

If you don't wish to create an account, you can create gists anonymously as well.

3. Add gist to GitHub

All you need to do in order to add a new gist is:

a. Create a name for the gist

b. Create a name for the file (this is optional)

c. Select a language

If you give the file a name, the system will determine what the language is from the extension.

d. Put the text of the code snippet in the body of the gist

e. Save the gist by clicking on the Save Gist button.

4. Add the gist in your post

In order to add the gist to your post, you will need to click on the show embed link and add the html snippet to the html content of your post. In this case,

Once you have added this, the code should appear in the post as below.

5. Add line numbers via additional css styles

You may notice once using the steps above that the native gists from GitHub do not support line numbers currently, so in order to add them I found a gist that contains the .css styles that you need to add to your blog site. Once added, all snippets appear with line numbers as you saw in point number 4.

If you find another way to do this by adjusting settings at GitHub, let me know in the comments.

Hope this helps!

Creating Data-Driven Tests in MS Test

2011-02-11T03:18:00.003-06:00

For my current client, I was looking for a way to create a data-driven unit test in MSTest. Basically, you can define a test once and then define a data source that provides multiple rows of data to be sent through the same test. That way, you don’t have to write redundant tests.
I had done this previously, but I couldn’t remember how it was done. I’m writing this post in order to remind myself and hopefully help someone out there.
1. Create a Test Method
The first step is to make sure you have a test method. You can do this by making sure that in your test project you have at least one class decorated with the [TestClass] attribute and a method with the [TestMethod] attribute.

[TestMethod]

public void Add_when_two_numbers_returns_proper_result()

When creating this test class, make sure to keep the TestContext property as it is defaulted. You will be using this when coding your test.

private TestContext _testContext;

/// <summary>

///Gets or sets the test context which provides

///information about and functionality for the current test run.

///</summary>

public TestContext TestContext

get

return _testContext;

set

_testContext = value;

2. Add a Test Data File

For the purposes of this explanation we will be using a simple .csv file (TestData.csv). Make sure to add a text file, preferably at the root of your project with that extension. In the file, you will want to add data. I have added three columns per row: Operand1, Operand2, and ExpectedValue which represents the expected result of adding the two operands together. You can add as many rows of data to check all of the boundary conditions that express your intentions for your unit test.

Right-click on the file and select Properties to set the Build Action to Content and the Copy to Output Directory to Copy Always as shown below. This will ensure that the file is copied to the Bin folder when running your unit tests.

3. Open the Test View from the Test menu.

From the Test menu, select the Windows –> Test View option as shown below.

Once you open the Test View, you should see a list of the test methods that are available. When a test is highlighted, you will see the properties for that particular test in the Properties pane as shown below.

4. Assign Test File as Test Data Source

Find the row for Data Connection String in the Properties pane and click on the button to the far right with the ellipses (…). That should open the following dialog where you will be presented with an option to set up a database, csv file, or xml file.

The database option should be self explanatory. It is like any other database connection, and the most popular option is to use a simple MS Access DB or SQL Express database that you can include with your project.

The other two options are file based. The CSV file will be explained in further detail below. The main difference between a CSV and XML file is that you can have multiple test data sets in the XML file while only one set of data would be accessible for a CSV. So, if you need to set up data for multiple tests, you would need to maintain multiple files with the CSV option. In the XML option, you could just maintain one with multiple sections within the XML file.

Select the CSV File option and click Next.

5. Select Your CSV File

At this point, you will be presented with a dialog to select a CSV file. Click on the (…) button and select the location of the text file that you created for your test.

Once selected, the dialog will show the contents of your CSV file as a data grid to allow you to examine the contents to make sure that the data is what you were expecting.

Click the Finish button once you have confirmed the file contents. You will notice that the properties have been updated to reflect the change.

In addition, Visual Studio will add a [DataSource] and [DeploymentItem] attributes to your original test method as shown below with the same information. In the future, you can set these attributes up on a test without needing to use the Properties wizard for selecting a Data Source.

[DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV", "|DataDirectory|\\TestData.csv", "TestData#csv", DataAccessMethod.Sequential), DeploymentItem("Demo.DataDrivenTests\\TestData.csv"), DeploymentItem("TestData.csv"), TestMethod]

public void Add_when_two_numbers_returns_proper_result()

6. Add Code to Reference Data Source

Once you have added your test data to the test method, you will want to access it within the body of your unit test method. This can be done by referencing the DataRow property of the TestContext class-level variable. I have created a simple test to use the values to assert that the Add method of a simple Calculator class works as shown below. Because a DataRow column returns an object, you will need to do some casting to the appropriate data types.

[DeploymentItem("Demo.DataDrivenTests\\TestData.csv"), DeploymentItem("TestData.csv"), DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV", "|DataDirectory|\\TestData.csv", "TestData#csv", DataAccessMethod.Sequential), TestMethod]

public void Add_when_two_numbers_returns_proper_result()

//arrange

var operand1 = System.Convert.ToInt32(TestContext.DataRow["Operand1"]);

var operand2 = System.Convert.ToInt32(TestContext.DataRow["Operand2"]);

var sut = new Calculator();

//act

var result = sut.Add(operand1, operand2);

//assert

var expectedValue = System.Convert.ToInt32(TestContext.DataRow["ExpectedValue"]);

Assert.AreEqual(expectedValue, result);

7. Run the Test

You can run the test as you would any other in MS Test. The result will look similar to other tests.

However, if you right-click on the result row in the Test Results pane, and select View Test Results Details as shown below…

…you will see the detail of the results to see which data combinations failed and why.

Hope this helps someone else out there.

Create Custom Test Category Attributes in Visual Studio

2010-09-30T22:35:00.003-05:00

In the past, for each class library project we create in Visual Studio, we have maintained separate unit test and integration test projects. This has allowed us to easily configure continuous integration with TFS to run a given project’s unit tests on check-in and run the full suite of unit and integration tests on a nightly build.
With the introduction of Visual Studio 2010, build types now can filter tests based on test categories.

For example, I can categorize a given test as a unit test by doing the following:

   [TestClass]
    public class Test
    {
        [TestMethod]
        [TestCategory("UnitTest")]
        public void IsValid_returns_false_when_quantity_large()
        {
        }
    }

This allows us to consolidate all tests into one project and distinguish by categories. The only issue is that these categories are based on strings that the developer must type, and this can create inconsistencies using magic strings which may not be noticed during the course of development.

In order to get around this, another option is to create your own custom test category attributes that return the proper string. Microsoft has provided a base class, TestCategoryBaseAttribute for this very purpose.

     public class UnitTestAttribute : TestCategoryBaseAttribute
    {
        public UnitTestAttribute()
        {}
        public override IList<string> TestCategories
        {
            get { return new List<string> {"UnitTest"}; }
        }
    }

By overriding the TestCategories property, you can return the appropriate string(s) that represent this classification. In this case, we are returning the same string that the previous test category provided.

In order to use this attribute, you merely need to add it to a given test method like so.

   [TestClass]
    public class Test
    {
        [TestMethod]
        [UnitTest]
        public void IsValid_returns_false_when_quantity_large()
        {
        }
    }

With this kind of flexibility, if you had a limited list of attributes that you wanted to provide to developers, you could also create an enum type and pass that into the constructor of the custom test category attribute.

Just create an enum type.

     public enum Category : int
    {
        UnitTest = 0,
        IntegrationTest = 1
    }

Then, create the attribute using the enum as a constructor parameter.

   public class TestCategoryAttribute : TestCategoryBaseAttribute
    {
        private TestCategory _category;

   public TestCategoryAttribute(TestCategory category)
        {
            _category = category;
        }

   public override IList<string> TestCategories
        {
            get
            {
                var value = Enum.GetName(typeof (TestCategory), _category);
                return new List<string>{ value };
            }
        }
    }

To use the new attribute, you would do the following.

   [TestClass]
    public class Test
    {
        [TestMethod]
        [TestCategory(Category.UnitTest)]
        public void IsValid_returns_false_when_quantity_large()
        {
        }
    }

Hope this helps!

Six Interview Questions for Agile Teams

2010-08-23T22:21:00.001-05:00

I was reading through my blogs tonight and came across one that did a nice job of explaining the qualities that an agile team member should possess. In addition, the writer included a good behavioral interview question for each.
I briefly share each below, but I highly recommend reading the original article.
1. People Who Collaborate
"Think back to a recent project. Give me an example of a time you had to work with other people to make sure that you could finish something. What happened?"
2. People Who Ask for Help
"Think back to your most recent project. Tell me about a time you did not understand something. What did you do?"
3. People Who are Willing to Take Small Steps and Get Feedback
"When you work on your projects outside of work, how do you work?"
4. People Who are Willing To Do Something That is Good Enough for Now
"Tell me about a recent time you did not know everything at the beginning of the project. What did you do?"
5. Adaptable People
"Tell me about a time when you did not have the conditions you would've liked for your project. What did you do?"
6. People Willing to Work Outside Their Expertise
"Tell me about a time you took on work to help the team. What was that like?"
So, tell me dear Reader – what questions do you ask when interviewing candidates for an agile-oriented team?

Motivations

2010-05-29T07:30:00.000-05:00

I found this video about what motivates people to be very refreshing. Basically, if the tasks that people are working on require more than a basic physical action, money rewards don't motivate, but rather demotivate people. What really motivates others to perform well at conceptual tasks are three things: autonomy, self mastery, and purpose. What I find is that Agile practices tend to foster or work within these motivations.

For example, user stories really help to zero in on the purpose for a given feature request. "As a [actor], I can [do something], so that I can [accomplish a goal]." Developers really get a sense for why they are building a piece of functionality rather than just focusing on building a method, etc. And the prioritization of these stories helps to clarify what is truly important within a sprint.

As well, agile practices promote mastery by emphasizing continual improvement. Teams are encouraged to use the processes that work for an individual team rather than trying to create a process that will work for an entire organization. Other principles such as refactoring and unit testing also suggest an intense focus on continually improving the code base.

And finally, the scrum meeting and agile planning in general focus on the team working together on deciding the priorities rather than having a central authority such as a PM do that. Individuals make themselves accountable to the team by explaining what they accomplished yesterday and what they plan to accomplish for the current day. This creates a sense of autonomy in those performing the work.

I would be interested to hear your thoughts on the video as well as whether or not you agree that agile practices help to foster these motivations.

Rick Warren Speaks on Meet the Press - Giving

2009-11-29T15:47:00.003-06:00

I really enjoyed seeing Rick Warren, the pastor of Saddleback Church in California, speak on giving on Meet the Press with David Gregory. (below)

And what influence he has - not just because he has a platform on national television, but because he actually gives 90% of his income. He has the authority to speak on this subject!

Visit msnbc.com for Breaking News, World News, and News about the Economy

Static Code Analysis - Part 2

2009-09-05T02:54:00.001-05:00

In my last post, I showed how you could enable static code analysis for a visual studio project. However, you can also set up static code analysis at a more global level if you are using Team Foundation Server for source code control.

Within a Team Project, you can set up a check-in policy that requires the code to pass static code analysis. You can do this by simply right-clicking on the Team Project and selecting Source Control from the Team Project Settings.

From the Source Control Settings dialog, click on the Check-In Policy tab. and click the Add... button. (Note - I already have the Code Analysis policy set for my project in the image below.)

Click the Add... button to add a new check-in policy and select Code Analysis from the menu.

From here, you should be able set up the rules just as you would at the project level. Any rules you specify should generate an error when violated, and therefore, the code will not compile. As a result, the developers will not be able to check-in code that violates any of the rules that you have set for the team.

So, if you have already set up rules within your projects, another nice feature in Visual Studio is the ability to synch up your settings in each project with those set at the check-in policy level. You can do this by selecting the Replace with Check-in Policy under Analyze/Code Analysis Settings for Solution in Visual Studio.

All of the settings in your current projects will match those set at the Team Project level. None of your previous suppressions attributes should have been removed.

Hope this helps!

Static Code Analysis - Part 1

2009-09-05T02:22:00.001-05:00

The static code analysis within Visual Studio is a great way of automating initial code review. In order to turn it on do the following.

1. Go to Properties within the particular project.

Code analysis can only be enabled at the project level, so the first step is to go to your properties section of each project you want enabled for code analysis.

2. Go to the Code Analysis tab.

3. At the top, check the box that "Enable Code Analysis on Build..."

4. On the right-hand side of the screen, check the box for those rules that you want treated as an error. (By default it is treated as a warning and will not stop the build process.)

Sometimes the rules may not make sense for projects where a lot of code is auto-generated. In this case, you could leave that rule as a warning in the project settings.

In other cases, you may want to suppress the errors for particular members of your types or for whole namespaces. This can be done by right-clicking on the rule violation in the Error List that appears when compiling your project and selecting a Suppress Message option.

As seen above, this can either be set within your source or in a project suppression file. You can learn more about this here.

JSON Serialization in .NET

2009-04-17T12:12:00.002-05:00

Many of you may be familiar with the use of JSON (JavaScript Object Notation). It is a very tight syntax for expressing the state of an object and is very widely used in Web 2.0/AJAX style development in which objects are passed back and forth between the client using the XmlHttpRequest object out of band to eliminate the need to do a full page refresh.

I found a great article by Rick Strahl that outlines the pros/cons of two built-in .NET serializers: JavaScriptSerializer and DataContractJsonSerializer. You can read about them here.

After using both methods in my own application, I found that another con of the JavaScriptSerializer that is a pro for the DataContractJsonSerializer class is that it requires a public default, parameter-less constructor. This means that I cannot serialize objects that I also would like to make read-only, and therefore, requires a constructor with the properties defined up front.

One point I wanted to make in this post was that the extension class that Rick defines in his post for simplifying DataContractJsonSerializer usage does not work properly. In order to correct it, I added the 'this' keyword to the first parameter so that .NET recognized the static methods as extensions to the object type. In addition, I converted the FromJsonString() method to a generic FromJsonString<T>() method to allow the return object to be strongly typed.

Code is listed below, if you are interested.

Changing the Default Browser in Visual Studio 2008 with ASP.NET MVC

2009-04-15T21:18:00.001-05:00

How frustrating! I spent at least 15 minutes trying to figure out how to change the default browser for debugging to my preferred browser in Visual Studio 2008.

Apparently, with a normal ASP.NET application, you can just right-click on any .aspx file and select 'Browse With...' from the context menu. The dialog that opens (shown below) has the option to select a browser and click 'Set as Default' button.

Unfortunately, the .aspx files in ASP.NET MVC applications don't don't provide this option in the context menu. The only one that works is the Default.aspx file.

I found the answer from this helpful blog post. Thank you, Steve Bodnar!

My recommendation to Microsoft is to either put this setting in the Tools/Options menu, which seems to be the most natural place to look for this setting, or place it in the Properties of the Web Site/Application project - which might be even better if you want to specify this setting per project.

Transparency is a Core Value in Work/Life

2009-03-11T19:36:00.001-05:00

I am working on a current project where we are trying to create a site that gives visibility/transparency into our company and its performance whether good or bad. This is being done in order to build relationship with those we do business with. And it occurred to me how fundamental transparency really is in work and life.

Lately, I have noticed a lot of examples of people and processes that are geared to pursuing transparency. Regardless of what I think of President Obama's policies, I have to say that he has been fairly transparent with his decisions and agenda. And every time some corruption (financial industry, legislative pork) or misbehavior is mentioned, his solution tends to be creating some framework (site or process) for exposing those ills through transparency.

It also occurred to me that a lot of project management processes aid us in exposing the truth about projects. Risk management helps to expose potential issues that can ruin a project's timeline or budget. Issues lists keep track of potential flaws in a given system. And project post-mortems can help teams to learn from past mistakes and improve for future iterations.

Even rating systems within eBay and Amazon or content updates from Facebook can help to bring a level of transparency that build trust.

So, why should transparency be so important?

For one, transparency builds trust. If someone knows the truth about me, whether good or bad, they can begin to expect certain behaviors from me. They can trust that I am who I say I am, and there is no fear that I will change or that there is something they do not know about me.

All relationships grow from a root of trust. Without it, there is no basis for relationship. So, if I want to grow quality relationships with my family, friends, and colleagues, I have to nurture trust, and therefore transparency.

It also creates a level of accountability. If I am transparent about my life and work to myself and others, I am forced to face reality. And even though reality is not always pretty, it can allow me to choose to pursue change. Without it, I can safely live in denial and be complacent with the way things are. And worse, if I keep things a secret, those failures may grow worse. It was once said, "You are only as sick as your secrets."

The Bible concurs with these benefits saying that,

"If we say we have fellowship with him while we walk in darkness, we lie and do not practice the truth. 7 But if we walk in the light, as he is in the light, we have fellowship with one another, and the blood of Jesus his Son cleanses us from all sin." (1 John 1:6-7)

You cannot have fellowship (relationship) with others and grow in your life without a level of transparency.

So, I have decided that transparency or being transparent needs to be a core value for me. And this blog post is my first attempt at admitting that I need to work on it. I need to be willing to be honest to others about my life and work regardless of the consequences and be humble enough to apologize when I have failed or hurt someone. It's the only way to have the quality relationships and integrity I desire.

Web Service Naming Conventions

2009-03-03T10:04:00.001-06:00

I was reviewing an interface for a WCF web service today, and I began wondering about web service naming conventions.

It is understood that a service should be a logical grouping of a set of functionality. Therefore, if you have several pieces of functionality that center around a Project concept, then you should group them together under the name ProjectService.

So, the convention for service names is:

Casing: Pascal case
Format: [concept noun] + 'Service' to construct the name.)
Examples: ProjectService, TaskService, PersonService, etc.

When creating methods for a data service, though, should you restate the concept in the title? In this case, you would use the following methods: CreateProject(), UpdateProject(), GetProjectByID(). Isn't this already understood by the title of the web service? So that you could say Create(), Update(), and GetByID() instead.

I propose no.

The latter might make more sense in an object-oriented world where you are operating on the object itself. However, a service is more like a manager class that operates on Project objects. Also, theoretically speaking, each one of these functions can live on their own apart from any other functionality. So, specifying the concept in the title of each method would make sense. And finally, there might be functionality in this service for sub-objects such as Task that would not be substantial/independent enough to live on its own in a TaskService.

In that case, it would be important to understand which type of object your Create(), Update(), and GetByID() are operating on.

So, my recommendation for a data web service methods is:

Casing: Pascal case
Format: [operation] + [concept noun] + [optional extensions]
Examples: CreateProject(), UpdateProject(), GetProjectByID()

What are your thoughts?

Team Foundation Server - Identifying All File Changes

2009-01-27T11:49:00.001-06:00

Within Visual Studio 2008, it is very easy to view the Team Foundation Server history of either a given file, project, or solution. All you have to do is right-click on the particular item, select View History from the context menu, and you are presented with a list of changesets as shown below.

From there you can double-click on a given changeset and see the files that were a part of that atomic check-in.

But how do you see a consolidated list of all files that have been modified since a particular date, label, or changeset? That is a little less intuitive.

The first step is to open the Source Control Explorer from the Team Explorer client window of Visual Studio by double-clicking on the Source Control Explorer node in the tree as shown below.

From the Source Control Explorer window, select the node within the project (either Team Project, Solution, Project, or file) and right-click to select Compare.

From there you will be presented with the Compare dialog shown below.

You can select to compare to a Changeset, Date, Label, etc. from the list. For purposes of this article, we have selected the compare by Date. Make sure that the only View Option selected in the checkboxes at the end of the dialog is "Show files that are different." Once you click the OK button, you will be presented with the following window displaying all of the files that have changed, grouped by solution and project.

Hope this helps.

The Effective Executive - Part 1

2009-01-11T17:45:00.001-06:00

So, I picked up a copy (used, by the way, from Amazon Marketplace for only $0.56 + shipping/handling) of The Effective Executive by Peter Drucker. It is by no means a new book, being released in 1966, but it has some very valuable wisdom on how to effectively execute as a knowledge worker that is as relevant today as it was then.

I am going to write several posts on the book, because I want to remember the important points from the book, and I would also like to share the most interesting portions with you. This first post will be a quick intro to the book.

The book is a mere 174 pages, but it takes time to read and digest the content. The first chapter discusses the need for effectiveness and idea that effectiveness can be learned by anyone.

What is effectiveness you say? Well, Drucker makes the distinction of doing the right things rather than do things the right way. Too many are busy doing work with no clue as to what contribution that work is really making to the organization.

After establishing the fact that effectiveness is important to knowledge workers and that effectiveness can be learned, the author then launches into 6 chapters explaining the most important aspects of practicing the habit of being effective.

1. Know where the time goes.

2. Focus on outward contribution.

3. Build on strengths - individual, peer, superior and subordinate.

4. Concentrate on a few major areas to achieve results.

5. Make effective decisions.

I have not read all of the chapters, but just skimming the book has provided invaluable insights into becoming effective. I will try to discuss each of the aspects above in future posts.

Random Resolution for the New Year 2009

2009-01-08T16:48:00.001-06:00

Well, it's that time of year again when we make New Year's resolutions. I am not a big fan of doing this once a year, because I believe that we should be daily looking for ways to grow and help others.

However, I found out about a site that randomly chooses a resolution for you from Caleb Jenkin's blog post today. It sounded simple enough. So, here's what it came up with for me.

Pretty appropriate, no? Try it out by clicking here.

Type-Safe Enum Strings in .NET

2008-08-18T23:44:00.002-05:00

One thing that has always bothered me in .NET is the inability to create a type-safe set of string constants like an enum. I would like to create a type such as the following:

public enum StoredProcedure : string
{
   DeleteConsumer = "DeleteConsumer",
   EditConsumer = "EditConsumer",
   GetConsumer = "GetConsumer"
}

This would be incredibly useful for those situations where you are passing constant strings to a given method and you would like to limit the options that are passed to a finite set of options that can be detected through a type-safe check during compile time.

public void ExecuteDataSet(StoredProcedures storedProcedure)
{
   SqlCommand command = new SqlCommand();
   command.CommandType = CommandType.StoredProcedure;
   command.CommandText = storedProcedure.ToString();
}

Unfortunately, a simple constant does not provide type-safe protection for the method call. If a developer is not aware of the pattern, they may end up sending in a literal string of their choosing. So, instead you end up with the following:

public void ExecuteDataSet(string storedProcedure)
{
   SqlCommand command = new SqlCommand();
   command.CommandType = CommandType.StoredProcedure;
   command.CommandText = storedProcedure.ToString();
}

After working at a heterogeneous shop, I learned that Java has been creating their own type-safe string enum classes for solving this situation for years before the formal enum type was added to the 1.5 release of the Java Runtime.

The example below shows how a typical Java developer would implement this concept in Java syntax.

public final class Color {

 private String name;

 private Color(String name) {
   this.name = name;
 }

 public String toString() {
   return this.id;
 }

 public static final Color RED = new Color("Red");
 public static final Color GREEN = new Color("Green");
 public static final Color BLUE = new Color("Blue");
}

The basic idea is simple:

1. Define a class representing a single element of the enumerated type

2. Don't provide any public constructors for it.

3. Provide public static final fields, one for each constant in the enumerated type.

Because there is no way for clients to create objects of the type, there will never be any objects of the type besides those exported via the public static final fields.

In order to make this easier to use within .NET, I create an abstract base type, StringConstantBase, that allows a developer to quickly create the functionality above plus some other goodies such as GetNames(), CompareTo(), Equals(), GetHashCode(), and the == and != operators for comparison to string literals.

In order to use the code, you merely define your class as follows:

public class StoredProcedures : StringConstantBase
{
   public static readonly StoredProcedures GetConsumer = new StoredProcedures("GetConsumer");
   public static readonly StoredProcedures EditConsumer = new StoredProcedures("EditConsumer");
   public static readonly StoredProcedures DeleteConsumer = new StoredProcedures("DeleteConsumer");

   private StoredProcedures(string name) : base(name){}

}

The only part that does not work (this is the same for the Java version) is that it cannot be used in switch...case statements. Those require the use of an underlying integral type which is not present. Instead, you should use the if...else if construct to perform the same logic.

If you are interested in using the StringConstantBase class for your own code, you can download my Visual Studio 2008 project from here. In addition to the class, I have included a unit test project to include my assumptions on its use.

I hope this helps someone out there...

Turning on Intellisense with Visual Studio 2008

2008-07-17T07:23:00.001-05:00

For whatever reason, when I was using Visual Studio 2008 this morning, I noticed that intellisense was not working. Whenever I typed the period at the end of an object reference, no list of available methods and their associated parameters was made visible as a drop-down.

I know that I am "man" enough to work without it, but I have come to really enjoy the productivity I get using intellisense - especially when learning a new API.

So, after exploring a bit, I found the settings and am documenting it here, so I don't forget for future reference.

1. Click on Tools/Options in the upper-menu.

2. Under Text Editor/All Languages navigate to the Statement Completion section at the top of the dialog and check the appropriate settings

There are 3 settings with the following explanation:

Auto list members - this is essential for intellisense to begin working.
Hide Advanced members - this will allow you to hide those properties, methods, and events that are not often used.
Parameter information - by default the auto list members only displays the name of the property, event, or method. You must have this option checked in order to display the actual parameter information.

I hope this was helpful...

Alessio's In Westlake Village, CA

2007-12-16T11:40:00.001-06:00

Tonight my manager and I are going to eat at Alessio's in Westlake Village, CA with a representative from IBM. I just wanted to add this post as a reminder of the restaurant location. I'm sure it will be very nice!

I have placed a map of the directions from the Simi Valley office of Countrywide (2900 Madera Road) to the restaurant below for future reference.

View Larger Map

Below is the actual location for the restaurant close up.

View Larger Map

Google for App Domains - Family Site

2007-07-15T22:14:00.000-05:00

My family and I are contemplating shutting down our existing family site at http://www.meinershagen.net/community and actually setting up shop with Google for App Domains. I am so blown away with the services that Google is offering for free (email, calendar, photos, pages, groups, blogs, docs, etc.) that I can't justify paying to host my own site anymore.

Have any of you had experience yet using the Google for App Domains? If so, what are some of the gotchas that you ran into when starting to use the service? Thanks in advance for any tips you have...

New SiteAvailabilityHttpModule - Based on Client IP Address

2007-05-30T23:30:00.001-05:00

As part of my company’s Technical Council, we are working on defining our process for promoting code from one environment to the next. One of the items we wanted to standardize across our enterprise was how we stop a site during a promotion.

ASP.NET 2.0 has a nice feature for shutting down a site called App Offline. As Scott Guthrie from Microsoft puts it, “the way [App Offline] works is that you place this file in the root of the application. When ASP.NET sees it, it will shut-down the app-domain for the application (and not restart it for requests) and instead send back the contents of the app_offline.htm file in response to all new dynamic requests for the application. When you are done updating the site, just delete the file and it will come back online.” You can find more out about this technique from the original blog entry here.

Unfortunately, our requirements were a bit more complicated than was intended with the app_offline.htm. First, most of our applications were written with the 1.1 framework, so this built-in functionality was not available for our use. In addition, we wanted the ability for testers to be able to validate the site once the changes had been made. However, we didn’t want to have to bring the site back up in order to do that.

As I was looking on line, I found another option called the SiteAvailabilityHttpModule. This module allowed for the site to be shut down by merely configuring an HttpModule within the web.config. In the Init() event, the module subscribes to the PostAuthorizeRequest event. Within the event handler, the system determines whether or not the request occurred during an accepted time frame and whether or not the requesting user belonged to the administrator role.

We didn’t need either of those features for our deployment. Instead of using a role-based mechanism for determining a user’s access, we wanted to base access on a configured list of client IP addresses. As a result, we didn’t need to wait until the PostAuthorizeRequest event – we could check these aspects within the first event – BeginRequest instead. The code is listed below.

void context_BeginRequest(object sender, EventArgs e)

{

string ext = Path.GetExtension(HttpContext.Current.Request.Path).ToLower();

if(ext == ".aspx")

{

if (this.IsEnabled)

{

if (!IsClientIPValid())

{

HttpContext.Current.RewritePath("~/SiteUnavailable.htm");

}

Notice that you must place a SiteUnavailable.htm file at the root of the site in order to display content if the user’s client IP address does not match one that is configured in the web.config. You can find the current release for this component here.

Decision to Reject a Counter Offer

2007-05-30T22:36:00.001-05:00

So – I have decided to leave my company of 4 ½ years. It was a difficult decision, as any decision is to leave your company is. I really have enjoyed working with the various teams that I have been involved with. The main driving force was a greater need to connect with people locally. I currently work out of a remote office in Dallas, with the rest of my team being in Chicago, but I enjoy the atmosphere of working with a local team and being able to informally discuss issues and connect at a more personal level.

The problem – I submit my resignation, and within a day, I receive a counter offer. I won’t go into the specifics of what they offered me, but suffice it to say that I began to wonder if it wouldn’t be worth my while to stay for another year or two.

I write this post to explain to others and remind myself of why I decided to stick with my decision to leave my current employer.

1. It’s all a mirage.

The offer from my current employer only really existed the moment that I put my resignation in. Therefore, it’s really just an illusion. I can’t rationalize or try to get myself to believe that these two options were going to exist at the time of my initial decision. It was flattering, though.

2. Potential Problems

I did all of the online research I could to see if accepting a counter offer was legitimate. Most information that I gathered suggested that it would not be a good idea, because 99% of the time the employee is gone within 6-12 months either because the original issue was not addressed by the counter offer or the employer replaced the person since they were disloyal. And most posts mentioned that it was an unethical move.

3. Integrity is at issue.

The moment that I began to entertain accepting the counter offer, I began to feel wrong inside. Although I agreed with all of the information I found online, that wasn’t what was really eating at me. I felt that I was wronging the company that I had said, “yes,” to. They would have to start their search all over again. That didn’t feel right. I couldn’t face myself in the mirror if I felt that I had done something to hurt someone.

4. Spiritual

And finally, as I lay in bed at night, I found myself crying out to God to give me wisdom. I wanted to make sure that whatever I chose to do, it was what the Lord thought was right. And at 2:00 am in the morning, the day before I rejected the counter offer, a verse came to my mind that I had not read for over 6 months: “Who swears to his own hurt, and does not change…” This is part of a larger passage of scripture in Psalms chapter 15, where King David asks “O Lord, who shall sojourn in your tent? Who shall dwell on your holy hill?” And the list that follows explains the qualities of one who can fellowship with the Lord. And keeping promises must be high on His list.

I couldn’t deny the voice of God. Accepting a counter offer was wrong not only because it isn’t real, it might potentially cause me harm, and it might damage my reputation with others. It might also cause harm to my neighbor – or in this case, my future employer. I couldn’t do that with a good conscience. It would keep me from fellowshipping with the One whom I don’t want to miss out on.

New Photo Albums

2006-09-10T11:19:00.000-05:00

I just began using Google's new beta Picasa Web Photo albums. It is so easy to upload photos from my existing Picasa photo organizer system. You can download the application here.

Here are a few new photo albums that I have posted from the month of June and July of '06. Enjoy!

2006 - End of Summer

Jul 5, 2006 - 42 Photos

2006 - Birth of Sophia Grace

Jun 22, 2006 - 10 Photos

2006 - Summer Fun

Jun 2, 2006 - 23 Photos

Free Services Online

2006-09-08T12:38:00.001-05:00

I am amazed at the amount of free services being provided on the internet! Will there be a day when I no longer have to maintain my own file share on a local hard drive? Will I be able to store everything out in the "cloud"?

Google has capitalized the market with free services like email, chat, calendaring, and photo albums. They are even offering to let you use their services as a suite for free within your small organization under your own domain. (http://www.google.com/a) Microsoft and others are trying to catch up with the services bandwagon, but clearly Google is in the lead.