A Digital Era

A Quick Post on Internationalization

2010-04-01T12:52:00.000-07:00

I haven't posted here in quite a while. Since that's the case, I thought I'd start things off with a quick laundry list of things to consider when you're dealing with localization in ASP.NET.

Absolutely and brutally minimize the number of images you have that contain text. Doing so will make your life a billion percent easier since you won't have to get a new set of images for every friggin' language.
Be very wary of css positioning that relies on things always remaining the same size. If those things contain text, they will not remain the same size, and you will then need to go back and fix your designs.
If you use character types in your sql tables, make sure that any of those that might receive international input are unicode (nchar, nvarchar, ntext). For that matter, I would just standardize on using the unicode versions.
If you're building SQL queries dynamically, make sure that you include the N prefix before any quoted text if there's any chance that text might be unicode. If you end up putting garbage in a SQL table, check to see if that's there.
Make sure that all your web pages definitively state that they are in a unicode format.
See Joel's article on Unicode - The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!)
You're going to be using resource files a lot for this project. That's good - ASP.NET 2.0 has great support for such. You'll want to look into the App_LocalResources and App_GlobalResources folder as well as GetLocalResourceObject, GetGlobalResourceObject, and the concept of meta:resourceKey. Chapter 30 of Professional ASP.NET 2.0 has some great content regarding that. The 3.5 version of the book may well have good content there as well, but I don't own it.
Think about fonts. Many of the standard fonts you might want to use aren't unicode capable. I've always had luck with Arial Unicode MS, MS Gothic, MS Mincho. I'm not sure about how cross-platform these are, though. Also, note that not all fonts support all of the Unicode character definition. Again, test, test, test.
Start thinking now about how you're going to get translations into this system. Go talk to whoever is your translation vendor about how they want data passed back and forth for translation. Think about the fact that, through your local resource files, you will likely be repeating some commonly used strings through the system. Do you normalize those into global resource files, or do you have some sort of database layer where only one copy of each text used is generated. In our recent project, we used resource files which were generated from a database table that contained all the translations and the original, english version of the resource files.
Test. Generally speaking I will test in German, Polish, and an Asian language (Japanese, Chinese, Korean). German and Polish are wordy and nearly guaranteed to stretch text areas, Asian languages use an entirely different set of characters which tests your unicode support.

Apple Disables iTunes for Palm Pre

2009-07-15T19:55:00.001-07:00

So I don't actually own a Pre - but I still think its fairly lame for Apple to produce a special release of iTunes whose only purpose is to disable Palm Pre syncing.

http://www.engadget.com/2009/07/15/itunes-8-2-1-brings-pres-music-syncing-capability-to-a-halt/

(I’m not posting heavy content this week, due to vacation. This blog will be back next week with the continuation of my prior article.)

Using ASP.NET AJAX and Web Services to Show Progress on Long Tasks, part 1 – Breaking the Task Up

2009-07-08T18:08:00.001-07:00

Introduction

One of the most powerful and compelling reasons to develop something as a application that runs natively on the user’s machine, as opposed to a web application, is responsiveness. The ability to give feedback about an action the user is taking, even if it requires a fair amount of computational time, and even to allow the user to cancel that action is a pretty useful ability. Even as javascript and XML-HTTP have enabled us to craft more responsive user interfaces to the user, the issue of responsiveness to run-longing actions is one that needs to be addressed. Fortunately, those same tools have given us the ability to bridge even that gap.

This series of articles will show how to use ASP.NET AJAX and jQuery to take a long-running task that can be broken up into elements and use that to provide the user with a dialog that provides them feedback on their progress. The particular example used will be running a large number of queries against some slow data source – it is naturally preferable that a faster way of running the queries be found, and the reader is asked to please excuse me for solving this problem and not that one in this series.

The Task

In order to accomplish this, we need to be able to break the task up into chunks. Determining what these chunks are is a task in and of itself. The size of the chunks is important - you’ll be calling them multiple times, so you want to pick a size that is large enough to be meanginful and not be overwhelmed by the overhead of the web service calls you’ll be making, and that is small enough that the interface will still feel responsive. You’ll also need to build a way to determine what the total number of chunks to return are.

Once this is done, wrap this logic in your business layer in whatever way you want to do. In this example, we’ll assume that there is a class like the following:

public interface BusinessObject
{
    // Returns the total number of operations required to 
    // finish this task.
    public int GetNumberOfOperations();

    // Performs some of the operations against a set of 
    // operations that may be empty. If nothing was done, 
    // return false. Otherwise, return true.
    public bool PerformOperation();
}

This code is an example interface, of course, your business object should more closely resemble your model.

Web Service

Having broken up your task, you’ll need to expose those two methods of the interface as a web service. One of the beautifal things about ASP.NET AJAX is that you can easily access web services that have been decorated with the special System.Web.Script.Services.ScriptService attribute through javascript, on the client. I’ll give more details on how to do that in the next article. For the meantime, you’re web session will look something like the following:

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Web;
using System.Web.Services;

[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
[System.Web.Script.Services.ScriptService]
public class TaskService : System.Web.Services.WebService 
{
    public TaskService()
    {

    }

    [WebMethod(EnableSession=true)]
    public int GetNumberOfSteps()
    {
        IBusinessObject obj = (IBusinessObject)Session["businessObject"];
        return obj.GetNumberOfOperations();
    }

    [WebMethod(EnableSession = true)]
    public bool PerformOperation()
    {
        IBusinessObject obj = (IBusinessObject)Session["businessObject"];
        return obj.PerformOperation();
    }
}

You’ll note that each of the methods above are decorated with EnableSession=true. This gives the service access to the same Session state as the rest of your ASP.NET application. In this case, I’m pretending an instance IBusinessObject has been stuffed into the session. In a real world application, you might want to make sure the current user actually has permissions to do the bulky task that they’re about to do.

Caveats

The caveats about this process are, actually, enough to make this only useful in some pretty rarified situations. For the one thing, you don’t actually generally want to do long-running tasks on your web server. Particularly if those long-running tasks are exposed to the outside world and might be called on by every person in the internet. Remember that these tasks, when run, are going to take up one of the worker threads of your ASP.NET pool and that there are a limited number of these. Thus, it is easily possible to take this to a level where your server will collapse underneath the load.

In the end, you might well be better served moving the operation off to another server (perhaps the database) as a scheduled task. You could then use this trick to refresh the status of that operation, instead.

Since I’m trying to solely concentrate on the trick in this series, I’m not going to go into that. But keep in mind the business object could easily get a StartOperation method to add the operation to the queue and a CheckOperation method to see how the operation is going.

Conclusion

I hope this at least whets your appetite. In the next article, I’ll show how to implement this into a web page using javascript and jQuery.

Posting Schedule

2009-07-02T11:26:00.001-07:00

One thing I’ve been trying to do with this blog is to use it more frequently. This particular blog has always been meant as a means for discussing my thoughts on software development topics and to show what I’ve been doing in terms of actually writing code. So in many ways, I’m attempting to use this blog to serve as a portfolio of sorts of the work I’ve done and my thinking regarding that work. There’s a longer entry about software craftsmanship and maintaining a portfolio that may come in the future.

In the meantime, however, I’ve decided I want to keep posting to this blog on a fairly regular basis. In this case, I thought I would start out with weekly entries. As it happens, the next six entries I’d like to add to this blog have already been conceived of based on work I’m currently doing or work I will soon be doing. So, here’s the schedule I’m going to try to keep to. Note that all dates are Wednesdays – this seems to currently work as a good day to write an entry, but I reserve the right to post at any time during the weke.

7/8/2009 – Using ASP.NET AJAX and Web Services to Show Progress on Long Tasks, part 1 – Breaking the Task Up

7/15/2009 - No Entry. This is the week of my birthday. I will, further, be attending a LARP convention for the Camarilla and running a game there.

7/22/2009 – Using ASP.NET AJAX and Web Services to Show Progress on Long Tasks, part 2 – Displaying the Progress in the User Interface

7/29/2009 – Authentication and Authorization using SAML, part 1 – The Overall Process

8/5/2009 - Authentication and Authorization using SAML, part 2 – The SAML Document

8/12/2009 – Authentication and Authorization using SAML, part 3 - Dealing with X.509 Certificates

8/19/2009 – Authentication and Authorization using SAML, part 4 – Putting It All Together in Code

After that, I’ll figure out what the next set of entries will be. Hopefully there’s stuff in there that people will find interesting to read.

Thanks,

John

jQuery

2009-07-01T16:35:00.001-07:00

One of the biggest challenges of developing for web applications has always been cross-browser javascript support. Different browsers would or would not support pieces of the DOM object model, or would implement them in different ways. The issues have been getting gradually better since the Netscape/Microsoft war ended and relevant W3C specifications came out. There are still, though, issues between Internet Explorer and Mozilla (and, presumably, other browsers). One example of this is in the way the browser divides up HTML content into the ChildNodes collection. Any element of the DOM that can support children supports the ChildNodes collection, which is meant to be a way to get at the children of a particular node.

The problem, though, is that Mozilla and Internet Explorer divide up content differently. The issue basically comes down to whitespace – Mozilla divides whitespace used in the markup into separate children, while Internet Explorer ignores it. I make no attempt to figure out which is, standards-wise, the correct approach. I will say that it seems more right to ignore whitespace, since when rendering HTML whitespace is pretty much ignored. And that treating it as significant seems to encourage compressed, poorly laid out code.

That said – I'm not in charge of the design of Mozilla's javascript rendering engine (and no, I'm not going to submit patches to an open source project just because I object to the way whitespace is dealt with. I don't have that much free time, thanks. And besides, the version which treats whitespace as significant is still out there in the wild and needs to be dealt with. In the past this has led to some complex javascript code. For instance, the following code block. In this case, I'm taking a collection of DIVs, each of which contain a SELECT and a TEXTBOX and pulling out the entered values. The values are then thrown to a web service, exposed through ASP.NET AJAX. Due to the fact that this DIV is cloned repeatedly on the page through user action, assigning ids to the nodes was not a particularly feasible option.

    
var newItemFormContainer = $get("newItemForm");
if (Sys.Browser.name == "Microsoft Internet Explorer") {
    var newItemCount = 
        newItemFormContainer.childNodes.length;
} else { 
    var newItemCount = 
        newItemFormContainer.childNodes.length - 1;
}
for (var i = 0; i < newItemCount; i++) {
    var itemText;
    var scaleId;
    if (Sys.Browser.name == "Microsoft Internet Explorer") {
        itemText = 
            newItemFormContainer.childNodes[i].childNodes[0].
            childNodes[1].value;
        scaleId = 
            newItemFormContainer.childNodes[i].childNodes[4].
            childNodes[1].value;
    } else {
        itemText = 
            newItemFormContainer.childNodes[i + 1].childNodes[0].
            childNodes[2].value;
        scaleId = 
            newItemFormContainer.childNodes[i + 1].childNodes[8].
            childNodes[3].value;
    }
    if (scaleId == "") {
        scaleId = null;
    }

    if (itemText != null && itemText.trim() != "") {
        GeneseeSurvey.SurveyDesign.ManageSurveysService.
            CreateItemAndAddToSurvey(itemText, scaleId, success, 
            surveyServiceCallFailure, i);    
    }
}

This is not particular a great solution. For one thing, it requires a conditional statement that is dependent on what browser the user is using. This can get messy and hard to maintain if there are other browsers with incompatibilities.

I would argue, though, that this code is bad from a design standpoint. Dipping into the childNodes collections as I was doing in the above example requires that you have extensive knowledge of the way the HTML page lays out user interface of the form DIVs. If that user interface is changed without the javascript being changed, the code will cease to function. Furthermore, the code is hard to follow – human eyes glaze over when they see you getting the second element of the zeroth element of the ith element. It would be very difficult to step back through the code and figure out what the developer was trying to do. So, refactoring this code would be a great thing. The problem being, though, that javascript will make it difficult to do this in a better fashion.

Lucky for us, a lot of other developers have had this problem in the past. And as developers are wont to do when they have a problem, a group of developers solved the problem by adding a new layer of abstraction. In this case they solved the issue by inventing jQuery. jQuery is a javascript library which adds a powerful set of querying capabilities which enable you to get at elements in an entirely new fashion. It also provides a powerful set of animation capabilities which enable you to make better user interfaces. That's for another blog entry, however.

With jQuery, you now have the capability to take an element of the DOM (or the entire document) and conduct a search based on a class name, an element name, an element id, or by the relationship of the target node to the current node. You are, further, not limited to creating one-level searches. For example, if you have a textarea underneath a div that has a class of 'textareacontainer', which is underneath a div which is the first child of the current div (which we'll assume has an id of 'firstDiv'), you can find it with the following piece of code:

var textarea = $("#firstDiv div:firstChild .textareacontainer textarea:first");

This will return a collection that has a single element. One gotcha of jQuery is that this will not be a collection of DOM objections. jQuery wraps all search results in its own object, which lets you then do further jQuery queries against the results. jQuery does provide a host of functions to manipulate common elements of the underlying DOM object. I could get the value of the textarea with textarea.val(), for instance. If I needed the DOM object, though, I could use textarea.get(0) and then do what I have to do.

Another thing that jQuery provides as part of its wrapper around DOM objects is the ability to iterate through the collection and carry out user code. This is provided through the each method, which takes as an argument a callback function which is executed once for each DOM element in the collection. Given this information, the following is the refactoring of the first javascript code block I had.


var newItemForms = $("#newItemForm > div");
newItemCount = newItemForms.length
newItemForms.each(function(i) {
    var itemText = $("textarea:first", this).val();
    var scaleId = $(".selectScaleDropdown:first", this).val();

    if (scaleId == "") {
        scaleId = null;
    }

    if (itemText != null && itemText.trim() != "") {
        GeneseeSurvey.SurveyDesign.ManageSurveysService.
            CreateItemAndAddToSurvey(itemText, scaleId, success, 
            surveyServiceCallFailure, i);
    }
});

I maintain that this code is significantly easier to read and much, much easier to maintain than the prior code.

It should be noted at this point that Microsoft has committed themselves to delivering jQuery with Visual Studio. If you are developing with Visual Studio 2008 SP1, then you may already have access to it – I'm not, to be honest, entirely sure (see below). They have also delivered intellisense around it, though I haven't worked with that yet. For more information, see Scott Guthrie's announcement.

If you are developing with Telerik, they have also begun shipping jQuery with their components. This is how I ended up getting jQuery into my web application, since we make fairly heavy use of the Telerik 2009 Q1 controls. It does, require a bit of a patch to get the $() functionality to work. See Atanas Korchev's blog post regarding this.

I fully intend to refactor a good portion of our javascript code to use jQuery. This will take some time since I need to develop new features as well, but I think the savings in the end will more than make up for the cost. Naturally, newly developed javascript code will make use of jQuery.

LINQ-to-SQL & Side-Effects

2009-06-29T17:40:00.001-07:00

So the project I'm currently working on relies fairly heavily on LINQ-to-SQL. Thus far it is has been an absolutely delightful experience, though one in which I have spent quite a lot of time passing DataContext derivatives into my business layer objects. I've been doing this because I was under the impression that the only way to register an object to be posted back to the database or removed from the database is through the InsertOnSubmit, InsertAllOnSubmit, DeleteOnSubmit, and DeleteAllOnSubmit methods on the DataContext object.

As it turns out, this is not entirely true. I discovered this when I attempted to do a copy of an object which has a property that points to another LINQ-to-SQL managed object. One possibility with this code is that the item being used as a conditional for the branch may not exist. In this case, we don't want to copy the Branching object.

The code, thus, was this:


Public Function CreateCopy(ByVal db As SteamDatabaseDataContext, _
    ByVal surveyItemMapping As Dictionary(Of Integer, SurveyItem)) _
    As Branching

    Dim copy As New Branching()
    copy.ExcludeFlag = ExcludeFlag
    copy.ParameterValue = ParameterValue
   
    If (surveyItemMapping.ContainsKey(SurveyItemID)) Then
         copy.SurveyItem = surveyItemMapping(SurveyItemID) ' BAD!
    Else
         Throw New ArgumentException(String.Format("The survey item that branch {0} is" + _
              "based on does not exist within the surveyItemMapping parameter.", BranchID))
    End If

    copy.ParamType = ParamType
    If (ParamType = 1) Then
         If (surveyItemMapping.ContainsKey(Convert.ToInt32(Parameter))) Then
              copy.Parameter = surveyItemMapping(Convert.ToInt32(Parameter)).SurveyItemID
         Else
              Return Nothing
         End If
    Else
         copy.Parameter = Parameter
    End If

    db.Branchings.InsertOnSubmit(copy)
    Return copy
End Function

Thus, if the branch is not valid, it should return nothing and not reach the db.Branchings.InsertOnSubmit(copy) call. When I executed this against a survey with a branch, though, it became quickly apparent that the code was, in fact, registering the new Branch to be inserted into the database. This actually caused a crash, since Parameter would be null and the database schema is set to not allow this.

It turns out, that the problem is the assignment to the SurveyItem property above (see comment). Setting the SurveyItem property of the new Branching object immediately marks the object as to be inserted. When we change the code to the following:

copy.SurveyItemID = surveyItemMapping(SurveyItemID).SurveyItemID

The code works find and the Branching object is abandoned.

Thus, it appears that a side-effect of assinging such a property is that the object is registered for an Insert. I wasn’t aware of this side-effect and it cost me a lot of debugging time. This is definitely an object lesson in understanding the side effects of property sets. Its also a lesson to me to, when designing my own code, minimize those side effects.

jQuery

2009-06-18T09:25:00.000-07:00

So I've been working with jQuery for the past few weeks - this is an open-source javascript library that was included with the Telerik controls we purchased. It is also, I believe, included with Visual Studio, or will be in a future release. Let me tell you, it makes things a lot easier. One example - moving table rows up or down in the table. This is actually quite difficult to do in Firefox (IE provides a non-standard method to do it for you) - the only way to do it that I've found is to clone the affected table row, remove the old one from the table and add the new one. I hate cloning objects. I'm not going to include the code on how to do this, because I didn't write it. But here's a link - http://www.w3hobbyist.com/web-designing/moving-table-rows-up-and-down-with-javascript/

Once I figured out that this was going to be hard to do, I thought I would try to do it in jQuery. I hit the documentation site for jQuery (http://docs.jquery.com/) and found the answer really quickly. In the examples below, pretend that tableRow is the row of the table that needs to be moved.

Moving an item down in the table:


     $(targetRow).insertAfter($(targetRow).next())

Moving an item up in the table:


    if (targetRow.rowIndex > 1) {
        $(targetRow).insertBefore($(targetRow).prev());
    }

That is,actually, pretty amazing.

VB.NET XML Literals

2009-02-23T12:24:00.000-08:00

So for our current project, we're working in VB.NET 9.0 - I won't go into our methodology or reasons for switching. That said, I've found that I'm not a huge fan of the language so far. It literally feels more difficult to express myself in than C#. While I acknowledge that this could well be because of the learning curve any new language involves, I find myself yearning for semi-colons and curly braces.

That said - the single thing I've found so far that VB.NET does better than C# is building web server controls in ASP.NET. This is because of the feature that, when I first read about it, I shunned - XML Literals. What this is is the ability to express XML documents or fragments in VB.NET directly, without having to go through the XML object models that the .NET framework provides.

I'll admit - when I first saw this feature, I chuckled a little to myself and then moved on. We had, after all, done this before - ASP was all about this sort of embedded code. Also, I couldn't see why I would want to create XML documents like that in the middle of my code. And, in most scenarios, I'm still reasonably sure I wouldn't. That said, why don't you tell me what you think the more readable code is:

    Protected Overrides Sub RenderContents(ByVal writer As HtmlTextWriter)
        Dim itemContainer = New HtmlGenericControl("div")
        itemContainer.Attributes.Add("class", "radioButtonItemControl")
        itemContainer.Attributes.Add("id", String.Format("item_{0}", Me.ItemId))

        Dim textContainer = New HtmlGenericControl("div")
        textContainer.Attributes.Add("class", "radioButtonItemControlText")
        itemContainer.Controls.Add(textContainer)
        If (FlagBlankItem And Not HasValidUserResponse) Then
            Dim flagSpan = New HtmlGenericControl("span")
            textContainer.Controls.Add(flagSpan)
            flagSpan.Attributes.Add("class", "error")
            flagSpan.InnerHtml = "*"
        End If
        textContainer.Controls.Add(New HtmlGenericControl("span") With {.InnerText = Label})
        textContainer.Controls.Add(New HtmlGenericControl("span") With {.InnerText = Text})

        ' Figure out if we need to set one of the scales as checked.
        Dim resp As Integer
        If (UserResponses.Count > 0) Then
            Int32.TryParse(UserResponses(0), resp)
        End If

        ' Write out the scale
        Dim scaleContainer = New HtmlGenericControl("div")
        scaleContainer.Attributes.Add("class", "radioButtonItemControlScale")
        itemContainer.Controls.Add(scaleContainer)
        Dim idx As Integer = 1
        For Each s As SerializedScale In Scale
            Dim scaleItem = New HtmlGenericControl("div")
            scaleContainer.Controls.Add(scaleItem)
            Dim scaleRadioButton = New HtmlInputRadioButton() With {.Name = ID, .ID = String.Format("{0}_{1}", UniqueID, idx), .Value = s.Value.ToString(), .Checked = (resp = s.Value)}
            scaleRadioButton.Attributes.Add("onclick", "doRadioButtonClick(this);")
            scaleItem.Controls.Add(scaleRadioButton)
            Dim scaleLabel = New HtmlGenericControl("label")
            scaleItem.Controls.Add(scaleLabel)
            scaleLabel.Attributes.Add("for", String.Format("{0}_{1}", UniqueID.Replace("$", "_"), idx))
            scaleLabel.InnerText = s.Text

            idx = idx + 1
        Next

        itemContainer.RenderControl(writer)
    End Sub

vs

    Protected Overrides Sub RenderContents(ByVal writer As HtmlTextWriter)
        Dim controlXhtml As XElement = _
        <div class="hierarchyItemControl" id=<%= String.Format("item_{0}", ItemId) %>>
            <div class="hierarchyItemControlText">
                <span><%= Label %></span>
                <span><%= Text %></span>
            </div>
            <%= GetScaleXHtml() %>
        </div>
        writer.Write(controlXhtml)
    End Sub

    Private Function GetScaleXHtml() As XElement
        Dim scaleDiv As XElement = _
            <div class="hierarchyItemControlScale">
                <%= From s In Scale _
                    Select <div>
                               <input type="radio" id=<%= String.Format("{0}_{1}", UniqueID, s.Value) %> name=<%= ID %> value=<%= s.Value %>/>
                               <label for=<%= String.Format("{0}_{1}", UniqueID, s.Value) %>><%= s.Text %></label>
                           </div> %>
            </div>

        Return scaleDiv
    End Function

(Note that these two controls are doing two slightly different things, but they are close enough to illustrate my point)

LINQ-to-SQL Issue

2008-11-13T09:01:00.000-08:00

So I've been working with LINQ-to-SQL for weeks now. And, as I've been saying all along, I've found it a perfectly delightful process that has really increased my productivity. Which isn't to say that I don't have any problems with it.

At the moment, for instance, I'm running head-long into a wall. I have several defined Entity classes (which map to database tables on a one-to-one basis). Since the LINQ designer adds these as partial classes, that leaves me free to add business logic to these entity classes.

Which is all well and good until you realize the following - to do pretty much anything to the entity classes, you're likely going to need to instigate database changes. If you want to add something to a list that is stored by the entity class, for instance, you'll need to be sure that that new object (which is likely in itself an entity class) is persisted to the database. If you make changes within your method, you'll want to make sure those changes are persisted to the database.

The LINQ-to-SQL way to persist changes is a derivative of System.Data.Linq.DataContext. It provides a method (SubmitChanges) which can be used to persist any changes made to loaded Entity classes to the database. It also provides access to a series of Table(of TEntity) properties, each one of which represents a type of Entity class tracked by that DataContext derivative. You use these to register new entities to be persisted (InsertOnSubmit, InsertAllOnSubmit) or to remove entities that are no longer needed (DeleteOnSubmit, DeleteAllOnSubmit).

In my opinion, the methods that are making these changes should be responsible for making sure those changes persist. Certainly, the code calling these methods can't possibly know about new entities that may have been added by the method.

The problem, though, is that there is no way to get to the DataContext object that created an Entity from within the scope of that Entity. No reference to the creating DataContext is held within the entity. There are no events or virtual methods that can be implemented to capture when an entity is being created, and stick a reference to the DataContext into the entity.

This means that if I want to include business logic methods inside my entities, I have to include a reference to the DataContext derivative that created the entity in its parameter list. And there's no way for me to actually check and make sure that the entity is actually being tracked by the DataContext derivative passed in - which could lead to some odd bugs down the line.

The other alternative is to put all my business logic in the DataContext derivative - which strikes me as bad because then I'm separating the functionality from the data the functionality operates against.

Bleh. In the end, I'll just end up adding a DataContext derivative parameter. But it annoys me that I have to.

Why I Love LINQ-to-SQL

2008-10-03T07:23:00.001-07:00

The task: given a Scale which may contain one or many ScaleTexts and are thus reflected in the SQL database as a Scales and ScaleTexts table with ScaleTexts having a ScaleId foreign key reference, create the Scale in the database.

The old method: Generate and execute SQL to create a scale in the database and save its id. Methodically go through each of the ScaleTexts and generate and execute SQL to create a ScaleText in the database.

The LINQ method (given items as an IEnumerable(of string) that contains the scale texts for the new scale, and Db represents the DataContext derived object for the project):


Dim scale = New Scale() With {.Name = String.Format("{0} - {1}", items.First(), items.Last())}
Dim englishId = GetEnglishLanguageId()
For i As Integer = 0 To items.Count() - 1
    scale.ScaleTexts.Add(New ScaleText() With {.ScaleLabel = items.ElementAt(i), _ 
                                               .ScaleOrder = i + 1, _ 
                                               .ScaleValue = i + 1, _ 
                                               .LangID = englishId})
Next

Db.ScaleTexts.InsertAllOnSubmit(scale.ScaleTexts)
Db.Scales.InsertOnSubmit(scale)
Db.SubmitChanges()

Return scale

To me, this is so much better. I'm not having to move my head from writing VB.NET code to writing Transact-SQL, I can stay within the object model I've been working with all along and just expect the DataContext object to handle actually updating the database. All of my code is compile-time checked, rather having to wait until run-time to find out if I messed up a SQL statement.

Yum.

Case Sensitive SQL

2008-10-03T07:21:00.000-07:00

Huh.

Never thought this would be the case, but it looks like there is a case where Transact-SQL is case-sensitive.

Consider the following example, pulled from http://netbard.livejournal.com/206329.html:

select col.value('@ID', 'nvarchar(max)')
from XmlImport (NOLOCK)
cross apply ImportDocument.nodes('/Project/Text') as tab(col)
where XmlImportId = 21

When run, this generates a list of ID attributes in the XML document - just like you would expect.

Now consider this statement (I'll mark the only change in red):

select col.value('@ID', 'nvarchar(max)')
from XmlImport (NOLOCK)
cross apply ImportDocument.Nodes('/Project/Text') as tab(col)
where XmlImportId = 21

Now Transact-SQL is not case-sensitive. This should work as well as the first version. Instead, you get the following error:

Table-valued function 'Nodes' cannot have a column alias.

If you fix the case of the 'Nodes' section, it works fine.

This is, in my opinion, very lame. A language shouldn't be part case sensitive, part case insensitive. Bad! Pick a side of the road, and stay on it!

Querying XML in a Tabular Format

2008-10-03T07:20:00.000-07:00

So, SQL Server 2005 provides some remarkable access to XML documents stored within XML column types of a table. The most interesting that I've found so far is that you can take the XML document stored in a column and run a query against that that will return it in tabular format. You can then use that and join it to other tables in order to make your updates.

To do this, you need to figure out the XQuery to get a rowset of nodes that you want to query against. Pretending that we have XML document:

<Projects>
<Project>
<Text ID="116" TypeID="2" Request="DoNotChange" Response="">
<en_us>Alpha</en_us>
</Text>
<Text ID="117" TypeID="2" Request="DoNotChange" Response="">
<en_us>Beta</en_us>
</Text>
</Projects>

A possible XQuery to get all the Text nodes might be '/Projects/Project/Text'. You then need to cross your original SQL query that will get the xml document in order to get the list of all Text. So:

SELECT * FROM XmlImport (NOLOCK) CROSS APPLY ImportDocument.nodes('/Project/Project/Text') as tab(col) WHERE XmlImportId = 1

I've bolded the applicable part of this query. You are applying the results of this query to your result set as column 'col' - fully delineated I believed its tab.col.

The above SQL statement will not work, however. If you run it you will get an error 'The column 'col' that was returned from the nodes() method cannot be used directly. It can only be used with one of the four xml data type methods, exist(), nodes(), query(), and value(), or in IS NULL and IS NOT NULL checks.' This because SQL needs to know what you want it to return; it has no way of representing xml data in a tabular format otherwise. In order to do that, you need to include XQueries in your select statement to declare what you want to get back. To whit:

SELECT col.value('en_us[1]') as 'Text' FROM XmlImport (NOLOCK) CROSS APPLY ImportDocument.nodes('/Project/Project/Text') as tab(col) WHERE XmlImportId = 1

This will return the following, based on our XML document from above:

Text
Alpha
Beta

You can, of course, join that statement with other SQL statements to produce views, updates, or whatever.

Development Environment

2008-08-12T07:22:00.000-07:00

So tomorrow we're having a meeting to discuss the development environment that we're going to use for an upcoming project. This has kept me somewhat busy thinking about it, but I'm reasonably sure I know what we need.

First, hardware. I'm going to be proposing that we buy a new server. A big, beefy server that can run up to three VM instances on it. Those three VM instances will be our development environment web server, our development environment database server, and a development server running a couple of other things. If we can't get one that will run three instances, than we'll get one that can run two instances and another, smaller one, for our development server

The development environment web server and db server are boring. IIS and SQL Server 2005. Yawn.

The development server is the really interesting thing - in one fell swoop I'm proposing updating a lot of our development practices:

Install Subversion as our source control client. This is head and shoulders above Visual SourceSafe, and represents a new model of source control that makes multiple people editing a file easier and makes it a lot easier to branch off the main development trunk. This will involve installing TortoiseSVN and AnkhSVN on developer boxes.
Cruise Control.NET. This is iffiest - I'm not sure I can get support for true continuous integration.
nAnt. If I can't get support for continuous integration, I'll need this anyways. Minimally, we're going to do nightly builds. They're the best way to determine that progress is being made and that quality is being maintained during the code construction phase of a project.
fxCop. This allows us to do code construction checking based on a set of rules generated by Microsoft guidelines. We'll be taking a close look to turn off rules that are stupid.

In addition, we'll be upgrading to Visual Studio 2008 as soon as possible . I believe the plan is to get the MSDN SKU of it, which will be awesome. We'll also be creating a seperate area of FogBugz for the use of this project and discussion best practices for using that.

Getting all this through will probably be a not easy task. But doing it will get us right on line for some world-class development environment characteristics. And it will make our projects more successful - which means it will be worth it.

Consuming SAML Identity Authentication - Introduction

2007-12-20T18:42:00.001-08:00

Introduction

One of the hot new topics in software development is the idea of a company buying a subscription to a piece of software. Instead of deploying that piece of software internally, with the host of IT needs and challenges that face any sort of deployment, they pay another company to allow them access to that software.

This has many advantages – the client does not need to deal with rolling the application out to many users. This can be especially troublesome if the application is only used once or twice in a two year period – perhaps the application is used to review results of a survey that only occurs every so often or perhaps the application is used to manage the employee's pension plan.

As with anything in software, though, there are disadvantages. The one that this entry is going to focus on is the problem of login propagation. Basically if each system that a client purchases uses a different login and password for the user, this can quickly lead to problems as more and more such systems are purchased. Think about all the online accounts that you have and how many passwords you've ended up with. This has security implications – the more usernames and passwords that a user has, the greater the possibility that they will be written down or made insecure. This is frankly unacceptable if, for instance, the system holds valuable confidential data.

Companies, of course, have usernames and passwords – users use them every day to log into their corporate accounts and do their job. It would be a lot easier if they could share that information with third-parties and use those accounts used for logins. This is, of course, impossible – no company is going to want to share such sensitive information with a provider. Not to even mention the difficulties of keeping that credentials store up-to-date in the face of new users, removed users, and required password changes.

In past years vendors have tried to address this need with proprietary solutions. Netegrity (now owned by CA) released a product called Affiliate Agent, for instance. Users on the way out of the corporate intranet were routed through a portal site. This redirected them to the service with credential information included in the HTTP request. An ISAPI filter runs on the provider's web site that intercepts the request, authenticates the user, and provides information about them in HTTP headers available to the provider's web application. This was a workable solution, though a proprietary one.

With newer, open standards coming out around passing, encrypting and signing information, however, there is now a better solution. Security Assertion Markup Language (SAML) is that solution.

What is SAML?

SAML is a way of expressing information about a user in a secure fashion. This can include pretty much anything – user ids, email addresses, phone numbers – generally speaking whatever can be exposed by the systems linked up with a corporation's security gateway (think LDAP).

SAML itself is a specification defined by the OASIS (Organization for the Advancement of Structured Information Standards) group of several leading companies. The specification itself works with several other standards – XML, XML-Signature, SSL, and (of course) HTTP. These combine to create a secure method for companies to pass credential information to their service providers.

How Does a SAML Request & Response Work?

The lifecycle of a SAML Request & Response is as follows:

The user clicks on the link to the provider's site (in this case we'll pretend the url is https://www.provider.com/).
The web application running on the provider's site looks at the request and realizes that it has no idea who this user is. It redirects the user to a pre-arranged portal site that is hosted by the customer.
The portal site determines who the user is. This can be done through a username/password combo, the user's domain credentials, or any number of different ways.
The portal site creates a SAML response – a piece of XML indicating who the user is.
The portal site signs the SAML response with its private key, including the public key (or not! Some implementations do not include the public key. In this case the customer and the provider will need to exchange that public key. More on this later.
The SAML response is encoded in base64 and dropped into a HTTP POST request (within the SAMLResponse key) to the original provider's site.
The provider pulls out the SAMLResponse data, decodes it, verifies the signature, and extracts the user id. Frequently this user id is compared to the provider's list of allowed user ids.
If the user id validates, the user is allowed into the provider's site to do their work.

SAML Responses

Here's an example of a SAML response:

<samlp:Response xmlns:saml="urn:oasis:names:tc:SAML:1.0:assertion" xmlns:samlp="urn:oasis:names:tc:SAML:1.0:protocol" IssueInstant="2007-12-20T15:29:18.082Z" MajorVersion="1" MinorVersion="1" Recipient="" ResponseID="SM3b3c34b2352b7fedbaa30f1d9dc5a0c28e697fbe53">
    <ds:Signature xmlns="http://www.w3.org/2000/09/xmldsig#" xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
        <ds:SignedInfo>
            <ds:CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
            <ds:SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>
            <ds:Reference URI="#SM3b3c34b2352b7fedbaa30f1d9dc5a0c28e697fbe53">
                <ds:Transforms>
                    <ds:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
                    <ds:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
                </ds:Transforms>
                <ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                <ds:DigestValue>7wS/K/2tMeEWLrPE2hVAxJOoMFI=</ds:DigestValue>
            </ds:Reference>
        </ds:SignedInfo>
        <ds:SignatureValue>Base-64 signature goes here.</ds:SignatureValue>
        <ds:KeyInfo>
            <ds:X509Data>
                <ds:X509Certificate>Base-64 certificate goes here</ds:X509Certificate>
                <ds:X509IssuerSerial>
                    <ds:X509IssuerName>CN=Trusted Secure Certificate Authority,O=Trusted Secure Certificate Authority,C=US</ds:X509IssuerName>
                    <ds:X509SerialNumber></ds:X509SerialNumber>
                </ds:X509IssuerSerial>
                <ds:X509SubjectName></ds:X509SubjectName>
                <ds:X509SKI></ds:X509SKI>
            </ds:X509Data>
        </ds:KeyInfo>
    </ds:Signature>
    <samlp:Status xmlns:saml="urn:oasis:names:tc:SAML:1.0:assertion" xmlns:samlp="urn:oasis:names:tc:SAML:1.0:protocol">
        <samlp:StatusCode Value="samlp:Success"/>
    </samlp:Status>
    <saml:Assertion xmlns:SM="http://www.netegrity.com/SiteMinder" AssertionID="SMb65e33e44ef3db1774911aea9b268074bb5fdbe0" IssueInstant="2007-12-20T15:29:18.071Z" Issuer="http://www.netegrity.com/SiteMinder" MajorVersion="1" MinorVersion="1" xmlns:saml="urn:oasis:names:tc:SAML:1.0:assertion">
        <saml:Conditions NotBefore="2007-12-20T15:28:48.062Z" NotOnOrAfter="2007-12-20T15:30:48.062Z">
            <saml:AudienceRestrictionCondition>
                <saml:Audience>http://www.netegrity.com/SampleAudience</saml:Audience>
            </saml:AudienceRestrictionCondition>
        </saml:Conditions>
        <saml:AttributeStatement>
            <saml:Subject>
                <saml:NameIdentifier Format="urn:oasis:names:tc:SAML:1.0:assertion" NameQualifier="www.netegrity.com"></saml:NameIdentifier>
                <saml:SubjectConfirmation>
                    <saml:ConfirmationMethod>urn:oasis:names:tc:SAML:1.0:cm:bearer</saml:ConfirmationMethod>
                </saml:SubjectConfirmation>
            </saml:Subject>
            <saml:Attribute AttributeName="SMContent" AttributeNamespace="http://www.netegrity.com/SiteMinder">
                <saml:AttributeValue></saml:AttributeValue>
            </saml:Attribute>
        </saml:AttributeStatement>
        <saml:AuthenticationStatement AuthenticationInstant="2007-12-20T15:29:17.000Z" AuthenticationMethod="urn:oasis:names:tc:SAML:1.0:am:unspecified">
            <saml:Subject>
                <saml:NameIdentifier Format="urn:oasis:names:tc:SAML:1.0:assertion" NameQualifier="www.netegrity.com"></saml:NameIdentifier>
                <saml:SubjectConfirmation>
                    <saml:ConfirmationMethod>urn:oasis:names:tc:SAML:1.0:cm:bearer</saml:ConfirmationMethod>
                </saml:SubjectConfirmation>
            </saml:Subject>
        </saml:AuthenticationStatement>
    </saml:Assertion>
</samlp:Response>

In the next post, I'll dissect the components of this request and explain what goes into a SAML response. After that I'll show how, in .NET, you can consume a SAML response, verify it, and pull out the user id.

Breaking Assumptions

2007-11-13T17:43:00.000-08:00

Usually when you do a project you talk to the people who are going to use it. You discuss with them what the product is supposed to do, and what conditions will break the product. You come to some agreement and you make some plans and assumptions based on those agreements.

Generally, the first of those assumptions will be broken in the first six months. That’s what happened to me today. And, as usual in these cases, rampant hacking was required.

Anyways, some context. Our reporting system defines, on a per-report basis, a set of views that we can guide a user through to give them a high-level view of their reporting data. We offer a PDF download of this "Summary View". The PDF download is implemented in SQL Server Reporting Services 2005. Since it is dynamic, we do this by defining an rdl for each type of page (stacked graph, difference graph, table, etc). An ASP.NET application is responsible for looking up what types of views constitutes a user's Summary View and, using the reporting services control shipped with Visual Studio 2005, getting the pdf for each individual page. We then use a third party component to put it together and ship it to the user.

Basically, charts in SQL Server Reporting Services 2005 don't span pages. So if you have a ton of rows in your chart, that chart will get scrunched up to the point of uselessness. This isn't such a good thing; it also isn't fixable with the component that ships with SSRS - this may not be true in a third-party component, but we really didn't have time to go price one out.

There is a fix - but it is one with drawbacks. Basically, you can embed a chart in the row of a table in such a way that it mimics chart functionality. To do this, you need to drag a table onto the form and set the dataset name for that table to the dataset you were originally going to plug into the chart. (In our case, it was something like StackedGraphData).

This is where you run into the first problem. If you simply drag a chart object onto the data area of the table you will get an error indicating that you can't do that: charts aren't supported in tables. This is mis-leading and entirely not true (mad props to my co-worker Greg for discovering this). What you need to do is get a property dialog for the table and switch to the Grouping tab. You're going to set up grouping for your table - just set it up to be some unique value in your data set (in our case, each item in the graph has a unique code that we could set it to. Your mileage may very, but there ought to be some sort of unique row identifier in your data). Hit OK.

Your table will now have several new rows: a new header, footer, a separator row between two groups, and at least two different group "bands". This is fine: delete what you don't need. You can now drag a chart onto the table area and set it up however you'd like. Remember that your chart is going to be repeated for each row of your table: you probably don't want a legend and may well not want axis labels.

There are, of course, drawbacks to this approach:

You're embedding a new chart object in each row of your table. This is not the most performance-happy thing you could be doing. Don't do this unless you really, really have to.
The charts are independent of each other, which means you'll have to do a lot more hacking than I was willing to put up with if you want to have an axis label that makes any sense.

Once this was accomplished, then came the next problem. Our chart is a stacked bar chart, with three values in blue, yellow and red. We wanted to have a legend attached to each page of the output that explained what was going on. This would normally be simple: just add a footer to the table and, in the properties of the footer, specify that it should be repeated on each page. Not for us, of course!

Where we ran into problems was the fact that none of the text for a report page is specified in the rdl itself. Instead, we store all the text in the database: this allows us to do things like override text on a per-project basis and, more importantly, to support as many languages as our heart desires. So, in the rdl, we've defined a few data sets that contain individual pieces of text for the report.

The problem here is that a textbox doesn't have a data set property. You need to specify it by creating an expression that specifically refers to the data set in question. Where this falls down is when you attempt to embed that textbox into a table: doing so will cause a run-time error as a textbox needs to refer to the dataset that's specified in the data region you're working in (for no readily apparent reason).

It took me a while of hacking to figure out the way around this issue. Basically: you cheat. Create a corresponding textbox for each textbox you want to put into the table, outside of the table. Have it get the value from the dataset you want, and set its visibility to false. Be sure to give it a good name. Then, in the textboxes in your table you're going to set the value equal to an expression that grabs the value of the hidden textbox: ReportItem!textbox1.Value. This will allow you to get around the rediculous data set rule.

Tomorrow I need to alter our ASP.NET application to, in only certain cases, substitute these new graphs for our old ones.

Rocovering from a Failed Process Crisis

2007-09-11T17:43:00.000-07:00

Introduction

If you are a member of an IT organization that supports a business process (as opposed to producing the product that the business sells, for instance), then there are some operational realities that you no doubt face. One of these is that there is probably at least one process that you work with that is failing.

Why do processes fail? There are several reasons, and very few of them are bad. No one, after all, sets out to create a failed process. No one sets out to create something that will lead to the cursing of their name. Nonetheless, processes fail for many reasons:

Business changes – I think this is the most common of the reasons a process fails; the business assumptions that process rested on change. This is sure to happen the longer a process is in place. The very success of a process, in fact, will guarantee that this will happen; as the business prospers either the load through the process increases to dangerous levels or the type of load changes fundamentally. This is equivalent to an earthquake cracking the foundation of the house.
Technology changes – This is another common failing. The base technology changes and things that were impossible before become possible. What was possible with VB6 and MS Access is not, after all, what is possible with C# and Microsoft.NET. If this was the case, why would anyone move to .NET?
Personnel changes – This can easily relate to the last two, but is important enough that it needs to be brought up separately. As people leave your company through retirement or simple job changes, the knowledge that they bring with them will leave with them. Thus, you can easily find yourself with no one who can support the current process.

One thing to note about each of these reasons, by the way, is that none of them are really indicative of a defective process. They are simply indicative that the conditions that the process has operated under has changed in such a way that makes using that process non-economical.

This is also not to say that every company with a failed process will find itself in a crisis. Your company might live with a failing process for weeks and months, even years. Until the business decision makers realize that the failing process is interfering with work in a severe enough fashion, there won’t be a crisis. Generally, you’ll probably need at least two of the items in the above list to be true. Probably all three, in fact. If that happens, then you case a failed process crisis.

What does a failed process crisis look like?

There are several defining characteristics of a failed process crisis that you need to be aware of.

The crisis is immediate. There are things that need to happen immediately; whatever the process was, the outputs of it still need to happen. Shutting down the business for a few days is not an option.
The crisis is long-term. All the same, the fundamental problem is that your business process is failing. You need to re-architect a process and that is not something that can be done overnight; it requires careful thought and development.
Its your fault, even if it isn’t. Sure you’ve been telling them for years that using an Access database as a multi-user database store is a bad idea. Sure you’ve been wanting to re-write the thing since you started. That doesn’t matter. What does matter is that the business process has failed and IT wasn’t immediately ready with a replacement. Yes, I know that you had no way of knowing when the server would fail, or when that key person would quit. And yes, its not fair. But that’s the way it is.

The Good News

So from what you’ve read so far, you’re probably despairing. And you should; a failed business process is a hard thing to deal with. There is good news here, though, to go with the bad. And that is this: you have never been more visible to the company than you are right now. If you respond well to this crisis than you’ve proven your worth to the company, in spades.

Of course, the bad news is that you have never been more visible to the company. If you fall down from this challenge, you’re probably going to need a resume. This is not a time for the faint at heart.

What do I do?

If you’ve read this far, than hopefully you’re ready for what needs to be done.

Get out of your office. Seriously. It may seem like you need to be in your office crunching code twelve hours a day, but you’re wrong. What you need to be doing is talking to the people who aren’t in IT. You need to know how things were done before; how can you improve anything if you don’t know that?

Arguable more important, though, is the political aspect. People need to see you helping to deal with the crisis. People need to think that you care about what they’re going through and that you are there to help them fix the problem. The caveat to this? Make sure that you are helping to deal with the crisis and that you really do care about what people are going through? Nothing will sink you faster than insincerity.

Think about the short term. Get your developers in your office. Include a representative of the people who have to go through the process. Ask yourselves this question: “What can we do in two weeks that will have best impact on the process?”

You’re looking for easy wins here; things that will make things easier without betting the farm. Two weeks is baseline; its fine if it really takes three weeks or a month. Generally speaking, though, your first few easy wins should be very short. Your goal here is to both make things a little better and make it clear that your group actually is making things better.

When considering these tasks, you’re judging them on two axis. First, what is the risk of doing this? How much chance is it that this is going to blow up in your face? How much chance is there that this is going to be an enormous win? Secondly, how long will it take? You want to keep these in opposition: if you’re going to try something that may blow up in your face, you only want to spend a day trying it. If you’re going to try something that’s probably going to save your rear, then spend two weeks doing it.

Just make sure that whatever you’re doing, you’re following the first rule. People really do need to know that you’re trying to make a difference.
Nothing is sacred. Seriously, the process is broken? Why are you holding up sacred cows when you have no food? Eat the damned cow. That may mean personnel changes. That may mean hiring temporary workers to help you. That may mean process changes. Leave nothing off the table.

That said, if you’re going to try to eat a sacred cow you need to be sure of a couple of things. First, you’re going to need buy-in. That’s the point of the all-important first step; hopefully by now you’ve gotten the buy-in and goodwill that you need. Second, it needs to work. Take into account the risk that it won’t, and be honest about confronting those risks. If your sacred cow gives you salmonella, you’re in deep shit.
Think about the long term. This crisis won’t last forever. When it ends, the urgency will go out of the situation. Don’t let that make you think that the fix is over. If you’ve been following these instructions, you’ve made a series of short term patches to the underlying problem. Essentially, you glued everything together with duct tape and baling wire.

Now its time to build something entirely new. This process is more akin to a traditional software process, so I won’t go into the full details of how to go about doing it. There are some things you need to consider.

First, a lot of the urgency has gone out of the process now that the immediate crisis is gone. You need to be the voice of reason here, reminding people of how bad it got and what still needs to be done. You need to keep building up good-will with everyone else in your company, because you’re going to keep spending it. People need to believe that you know what you’re talking about
Act. This is the last point, but probably one of the most important. You need to act. You can’t stand still. If it looks like things are bogging down into discussions and meeting after meeting, then do something. You need to drive everyone to action.

This does not mean you act without thinking. Hold meetings. Be sure, though, that the right people are around the table. You need to be holding meetings with the people who are going to be involved in this failed process. And if a meeting looks like its driving towards no action, then push. Try to get everyone to agree on an action, no matter how small. Then go do the action and start again.

This is going to be hard; probably the hardest part of this process. There’s a lot of motivation towards inaction, towards getting group consensus and not acting until everyone knows everything that needs to be done. Letting these fears bog down this recovery process, though, will kill you as sure as tying a plastic bag to your head.

That’s it in a nut-shell. There are tons of more points that need to be made, and situations that are specific to your specific company will come up. Be flexible, be aware, and be damned good, and you’ll make it through this mostly un-singed.

Good luck.

John Christensen

First Post

2006-08-25T13:08:00.000-07:00

This is my first post using this. I'm interesting in seeing if blogger has the tools needed for me to use javascript in there. I'd love to add in my starred items from Google Reader, or add in analysis from Google Analytics.