Miscellaneous Jibberish

Moving

2011-08-04T19:13:00.000-05:00

I've decided to move my blog over to WordPress.

You can now find all my old posts plus any future posts here: http://jeremywiebe.wordpress.com/

Knockout.js - cleaning up the client-side

2011-06-16T20:31:00.003-05:00

I've started a new project with a client and it's quite a shift for me. Coming off a heavy client (WinForms), 3-year project I'm now working in ASP.NET MVC and javascript. One of my goals with regards to the architecture was to keep a handle on the javascript. The project is integrating with the ESRI ArcGIS Javascript API and so there will be lots of client-side javascript and it will be important to keep it organized and maintainable.

In looking around for javascript libraries to help with this I found Knockout.js. This is a library for building larger-scale web applications that use javascript more heavily.

Knockout works by extending the properties of your javascript models (basically a POJO... Plain Old Javascript Object). You can then bind your model to the view (HTML elements) by marking up the HTML elements using "knockout bindings" (there are quite a few to choose from and they're listed here). Basically a knockout binding is a way to bind a property on your model to a specific attribute of an HTML element. There are quite a few that come built into Knockout (including things like text, visible, css, click, etc).

Once you've got the view marked up you simply call

ko.applyBindings(model);

and Knockout takes it the rest of the way.

Let's walk through a simple example as that'll make things more clear (I'm going to use the same Login UI example as Derick Bailey used for his first Backbone.js post so it's a bit easier to compare apples-to-apples... hopefully).

The layout is very similar to a Backbone view except that in a Knockout view you add extra 'data-bind' attributes.

Notice the 'data-bind' attributes in the markup. These dictate how knockout will bind the model we provide to the UI. Let's move on to the model now.

This is very close to being a simple javascript object. The only trick is that any property that we want to bind to the UI should be initialized via the ko.observable() method. The value we pass to the ko.observable() will become the property's underlying value.

Once we've instantiated a model object we simply call ko.applyBindings() and Knockout does the rest. (Note that the second parameter is the HTML element that should be the root of the binding. It is optional if you are only binding one object to your page, but I think in almost any application you'll get to a point where you want to bind multiple objects so this shows how to do that.)

At this point Knockout will keep the UI and model in sync as we manipulate it. This is full 2-way binding for the text elements. So if the user types in the username field, the model's username property is updated. If we update the model's username property the UI will be updated as well.

Derick noted in his blog post the mixing of jQuery and Backbone.js. I'm doing some of that here, but I think Knockout.js doesn't need jQuery as much because of how the binding is declared (on the HTML elements themselves).

I'm going to try to follow Derick's excellent series of posts on Backbone.js and comment on how the subjects he discusses compare and contrast with Knockout.js.

In the end I think both are very capable libraries even if they come at the problem from slightly different angles. In the end it's all about better organization of javascript and better assignment of responsibilities in the javascript you write.

Getting Started with AutoTest.Net

2011-04-21T22:50:00.002-05:00

I recently came across a new tool called AutoTest.Net. This is a great tool if you are a TDD/BDD practitioner. Basically AutoTest.Net can sit in the background and watch your source tree. Whenever you make changes to a file and save it, AutoTest will build your solution and run all unit tests that it finds. When it has run the tests it will display the failed tests in the AutoTest window (there is also a console runner if you are a hardcore console user).

This takes away some of the friction that comes with unit testing because now you don’t have to do the step of build and run tests during development. Simply write a test and save. AutoTest runs your tests and you see a failed test. Now implement the code that should make the test and save again. AutoTest again detects the change and does a build and test run. This cycle becomes automatic quite quickly and I’m finding I really like not having to explicitly build and run tests.

Features

AutoTest.Net sports a nice set of features. You can see the full list of features on the main GitHub repo page (scroll down) but here’s a few. It supports multiple test frameworks including MSTest, NUnit, MSpec, and XUnit.net (I believe other frameworks can be supported by writing a plugin). It can also monitor your project in two different ways. One is by watching for changes to all files in your project (ie. watching the source files). The other is by watching only assemblies. Using this second method it would only run tests when you recompile your code manually. I’m not sure where this would be preferred but I might find a use for it yet.

Edit: Svein (the author of AutoTest.Net) commented that one other compelling feature is Growl/Snarl support. If you have either one installed you can get test pass/fail notifications through Growl/Snarl, which means you don't have to flip back to the AutoTest window to check that status of your code. Nice!

This leads me to one other feature that I missed and that is that AutoTest.Net is cross-platform. It currently supports both the Microsoft .NET framework as well as Mono. This means you can develop on OS X or Linux.

Getting AutoTest.Net

So, to get started, download AutoTest.Net from GitHub. The easiest way is to click the “Downloads” link on the main AutoTest.Net project page and click one of the AutoTest zipfile links (at this time AutoTest.Net-v1.1.zip is the latest).

Once downloaded, unzip to a directory that you’ll run it from. I’ve put it in my “utilities” directory. At this point you can start using AutoTest.Net by running AutoTest.WinForms.exe or AutoTest.Console.exe. If you run the WinForms version, AutoTest will start by asking you what directory you’d like to monitor for changes. Typically you would select the root directory of your .Net solution (where your .sln file resides). Once you’ve selected a directory and clicked OK, you’re ready to start development.

The screenshot above is the main AutoTest.Net window. You can see that it ran 1 build and executed a total of 13 unit tests. The neat thing is that now as I continue to work, all I need to do to cause AutoTest.Net to recompile and re-run all tests is to make a code change and save the file. This sounds like a small change in the regular flow of code, save, build, run tests. However, once I worked with AutoTest.Net for a while it started to feel very natural and going back to the old flow will feel like adding friction.

Configuration

Alright, so we have AutoTest.Net running and that’s good. As with most tools, it comes with a config file, AutoTest.config (which is shared between the WinForms and Console apps). This config file is well-documented so for the most part you can just open it up and figure out what knobs you can adjust.

Overriding Options

One nice feature that AutoTest.Net has is that you can have a base configuration in the directory where the AutoTest binaries reside but then override it by dropping an AutoTest.config file in the root directory that you are monitoring. This allows you to keep a sensible base config in your AutoTest application directory and then override per-project as needed. Typically I’ve been setting the “watch” directory as the directory that my .sln file is in and so you’d drop the AutoTest.config file in the same directory as the .sln file.

In the above screenshot I have the AutoTest.config file which overrides a few settings, one of which is the ignore file: _ignorefile.txt.

IgnoreFile Option

One option that is useful is called the IgnoreFile. This is well-documented in the config file but it didn’t click with me initially. The IgnoreFile option specifies a file that contains a list of files and folders that AutoTest.Net should ignore when monitoring the configured directories for changes. The config file mentions the .gitignore file as an similar example so if you are familiar with git, it should make sense. The one piece that took me a while to figure out was where this ignore file should go. I finally figured out that if you put it in the root of the monitored directory (ie. beside your .sln file), it will pick it up (see above screenshot).

Wrapping up

AutoTest.Net is a great tool to help with the Red, Green, Refactor flow. It removes some of the friction in my day-to-day work by eliminating the need to manually invoke a compile and test run.

Lastly, the observant readers will have noticed that I said it builds and runs all tests any time it notices a file change. Greg Young is working on a tool called Mighty Moose that builds on top of AutoTest.Net as an add-in to Visual Studio (I think there’s a standalone version too). Mighty Moose ups the ante by figuring out what code changed and what tests would be affected by that change. It then only runs the affected tests, significantly cutting down the test run time.

Querying XML Columns in SQL Server 2008

2011-01-04T18:56:00.001-06:00

We make use of XML columns in a few places on our current project. XML columns are great for storing “blobs” of data when you want to be able to change the schema of the stored data without having to make database changes (it also provides flexibility in what you store in that column).

Occasionally, we need to query based on parts of the XML in these columns. Now because these are XML columns it’s not quite as easy to query on parts of the column as an int or nvarchar column. This is further complicated when the XML being stored uses namespaces.

Let’s start with the following table:

And here’s a sample of the XML stored in the column:

<CustomerInfo xmlns=http://schemas.datacontract.org/2004/07/Sample.Dto
              xmlns:i="http://www.w3.org/2001/XMLSchema-instance"
              xmlns:d="http://custom.domain.example.org/Addresses">
    <FirstName>Jeremy</FirstName>
    <LastName>Wiebe</LastName>
    <d:Address>
        <d:AddressId>82FC06FA-46A9-47CA-81AA-A0B968BCEE49</d:AddressId>
        <d:Line1>123 Main Street</d:Line1>
        <d:City>Toronto</d:City>
    </d:Address>
</CustomerInfo>

Now we could query for this row in the table by first name using the following query:

WITH XMLNAMESPACES ('http://www.w3.org/2001/XMLSchema-instance' as i, 
                    'http://schemas.datacontract.org/2004/07/Sample.Dto' as s,
                    'http://custom.domain.example.org/Addresses' as d)
select CustomerInfo.value('(/s:CustomerInfo/s:FirstName)[1]', 'nvarchar(max)') as FirstName,
       CustomerInfo.value('(/s:CustomerInfo/s:LastName)[1]', 'nvarchar(max)') as LastName,
       CustomerInfo.value('(/s:CustomerInfo/d:Address/d:City)[1]', 'nvarchar(max)') as City,
from Customer
where 
    MessageXml.value('(/s:CustomerInfo/d:Address/d:AddressId)[1]', 'nvarchar(max)') = '82FC06FA-46A9-47CA-81AA-A0B968BCEE49'

This would list out the FirstName, LastName, and City for any row where the AddressId was ‘82FC06FA-46A9-47CA-81AA-A0B968BCEE49’. There are a two things to note:

Namespaces

Any time you query XML (in any language/platform) that include XML your query must take that into account. In T-SQL, you define namespaces and their prefixes using the WITH XMLNAMESPACES statement. This statement defines the namespace prefix and associated namespace URI.

Once you’ve defined them, you can use the namespace prefix in your XPath queries so that you can properly identify the XML elements you want. One final note about namespaces here is that we have to define a namespace prefix for the namespace that was the default namespace in the XML sample. As far as I know there’s no way to define a default XML namespace using the WITH XMLNAMESPACES statement.

XPath Query results

Notice that the XPath queries (the CustomerInfo.value() calls) always index into the results to get the first item in the result. The .value() function always returns an array of matching XML nodes, so if you only want the first (which is often the case, you need to index into the results. Also note that with these XPath queries, the results are a 1-based array, not 0-based. So in this example we’re always taking the first element in the result set.

There are other functions you can use to query XML columns in T-SQL and you can find out more about this in the Books Online or via MSDN. This page is a good starting point for querying XML columns: http://msdn.microsoft.com/en-us/library/ms189075.aspx.

Uncovering intermittent test failures using VS Load Tests

2009-09-03T08:22:00.001-05:00

Our team build has been flaky lately with several unit tests that fail intermittently (and most often only on the build server). I was getting fed up with a build that was broken most of the time so I decided to see if I could figure out why the tests fail.

Working on the premise that the intermittent failure was either multiple tests stepping on each other’s toes or timing related. I decided the easier one to figure out would be the timing issue.

To create a new load test:

1) Select “Test –> New Test” and select “Load Test” from the “Add New Test” dialog

2) You will be presented with a Wizard that will help you build a load test. I don’t know what each setting means, but for the most part I left the settings at their defaults. I’ve noted the exceptions below.

a) Welcome

b) Scenario

c) Load Pattern

d) Test Mix Model

e) Test Mix

The Test Mix step allows you to select which tests should be included in the load test. For my purposes, I selected the single test that was failing intermittently. If you select multiple tests this step allows you to manage the distribution of each test within the load.

f) Counter Sets

g) Run Settings

Finally, you are able to manage the Warm up duration and Run duration. Warm up duration is used to “warm up” the environment. During this time the load test controller simply runs the tests but does not include their results in the load test. The Run duration represents how long the load test controller will run the mix of tests selected in the “Test Mix” step.

Once you click Finish, you will be presented with a view of the load test you’ve just created. You can now click on the “Run test” button to execute the load test.

Gotcha: The first time I tried to do a load test it complained that it couldn’t connect to the database. You can resolve this by running the following SQL script and then going into Visual Studio and selecting Test –> Administer Test Controllers… This will bring up the following dialog.

The only thing you need to configure in this dialog is the database connection (the script will create a database called “LoadTest”) so in my case the connection string looked like this:
Data Source=(local);Initial Catalog=LoadTest;Integrated Security=True

Now that you have the load test created, you are ready to run it. Click the “Run test” button on the load test window (shown below).

While the load test is running, Visual Studio will show you 4 graphs that give you information about the current test run. You can play with the option checkboxes to show/hide different metrics.

In my case, as the load test ran the unit test I’d selected started to fail. This at least showed me that I could reproduce the failure on my local machine now.

Next I added a bit of code to the unit test prior to the assertion that was failing. Instead of doing the assertion I added code to check for the failure condition and called Debugger.Break().

I ran the test again, but this time as I hit the Debugger.Break calls I could step through the code very well because the load test was running 25 simultaneous threads (simulating 25 users). I dug around a bit and found that you can change the number of simultaneous users. You can adjust the setting by selecting the “Constant Load Pattern” node and adjusting the “Constant User Count” in the Properties window.

I ran the test again and this time I was able to debug the test and figure out what was wrong.

Overall using the load test tool in Visual Studio was quite easy to set up and get going. Other than the requirement of a database (which is used to store the load test results) it was very easy to set up.

Lessons learned using an IoC Container

2009-08-26T16:39:00.004-05:00

I am working on my first project that’s using an IoC container heavily. Overall it’s been a very positive experience. However, we have learned some things have caused us pain in testing, bug fixing, and general code maintenance.

Separate component registration from application start-up

This is a constant source of problem on our project. If you don’t separate component registration from your component start-up path you often run into a chicken-and-egg problem. You may be resolving a component that depends on other components that haven’t yet been registered. This makes for a very brittle start-up path that is prone to breakage as you add dependencies to your components. Now the container that is supposed to decouple things is causing you to micromanage your component registration and start-up.

The solution is to split registration from component start-up. This makes perfect sense to me now, but wasn’t so obvious when we started the project. Lesson learned!

Be careful with a global service locator

We went quite a while without using a global service locator (essentially a singleton instance of the container) but eventually found that we needed it. This might have been avoided with better design-fu but we couldn’t think of a better alternative at the time.

What we found was that the global container made things difficult to test. This became especially painful when we needed to push mock objects into our container and than manually clean up the registrations to replace them with the production components that other tests might expect. I’d be interested in hearing if you have a way to solve this problem, and if so, how.

Use a Full-Featured Container

When we started the project we had intended to use Enterprise Library for some features. EntLib has Unity integration so we settled on using Unity as our IoC container by default. The container itself has served us extremely well. What we’ve found lacking in the container though is it’s supporting infrastructure features. A container like StructureMap comes with alot of nice features that aren’t core IoC features. For example, it reduces the “ceremony” (as Jeremy D. Miller would say) of registering components by providing convention-based component registration. StructureMap also provides detailed diagnostics that help you figure out what’s wrong with your component registrations if things don’t work.

That summarizes the biggest points that we’ve learned so far. I’d be interested to hear some “gotchas” that you’ve learned from using an IoC container “in anger”.

An Introduction to StructureMap

2009-08-10T21:40:00.000-05:00

Over the next several months I will be presenting a walkthrough of StructureMap. I will be starting with the basics of how to construct objects using StructureMap and then move on to more advanced topics.

I know there is lots of great information out there around how to use StructureMap. My intention for writing this series is mostly selfish. I want to learn StructureMap, and as I learn it I'll be blogging the features I'm learning as I go.

I’m currently working on a project that uses the Unity dependency injection container. This container has worked very well for us, but as I’ve read various blogs and articles I’ve come to realize that a good DI container provides more than just DI. It’s my intention to learn the basic usage of StructureMap, but also dig into the more advanced usages as well as much of it’s support infrastructure that helps you keep your dependency injection code to a minimum (thinking of auto-wiring, convention-based registration, etc).

I’ll also be updating this post as I write each new article so that this post can remain as a table of contents for the whole series.

Manual component registration and resolution
Auto-wiring components
Convention-based registration
Component lifetime management

Beware Calculations in Unit Tests

2009-08-03T21:32:00.001-05:00

Today our project’s continuous integration build failed. I traced it down to a unit test that was exercising a scheduling class. The class takes a schedule and figures out the next time it should run based on the current date.

Now in our project we’ve provided a way to stub the current date or current time by having a SystemClock class that has a static Instance property. If we need to we can push a stubbed instance into that property in a unit test to control what the current date/time is.

The problem in the unit test was that it was relying on DateTime.Now and then figuring out what the expected next scheduled time should be right in the unit test. The calculations were wrong in the unit test and caused the unit test to fail.

Almost every time I see calculations in unit tests to figure out what the expected value should be (especially date-based calculations) I cringe because I see those as unit tests waiting to fail. If you’ve copied your calculations from the class under test, who says you got the calculations right in the production class? If you did the calculations differently, your unit test’s calculations could be wrong. Wherever possible I prefer to keep the moving parts to a minimum and have constant dates as my expected values in date-based unit tests.

ReSharper 4.5 - Tip #2 - Generate Members

2009-05-22T16:02:00.001-05:00

One of the other developers on the team I'm on pointed out a very handy feature in R# yesterday. It is the "Generate Members" feature and can be accessed using Ctrl+Ins. This handy tool is like a central point to accessing the generation features in R#. The nice thing is that the generated members are placed at the current location and you can generate as many members as you like in one shot. This makes doing things like wrapping a bunch of private fields really easy. So, the next time you are using Alt+Enter (Quick Fix) to generate some code using R#, consider using Alt+Ins and see what it can do.

ReSharper 4.5 - Tip #1 - Wildcards in Go To Type shortcut

2009-05-06T11:21:00.002-05:00

I tend to use the Go To Type shortcut in R# alot (ctrl+N for you keyboard junkies). It was only recently that I found out that you can use simple wildcards when using the shortcut.

In the above screenshot you can see that I'm looking for all classes that start with "Pet" and end with "View". I don't use this feature every time I want to jump to a type, but often I can't remember the exact name of a class but I'll know pieces of the name and this helps in those cases (it's especially helpful when I just know how the class name ends, eg. "*Presenter").

Build steps in Team Build

2009-04-15T10:59:00.001-05:00

This is mostly for my own sake, but here's a link to the list of targets that are run during a Team Build on TFS 2008. Customizable Team Foundation Build Targets

Visual Studio Team System - The option that I've been missing all these years (Filter by Solution)

2009-02-03T08:47:00.002-06:00

I've been using Team System for a number of years, and one thing that was frustrating was that the Pending Changes window showed all files in the current workspace. This becomes unmanageable when you have several projects sharing a workspace (whether that's "best practice" is irrelevant).

Today I happened upon the option that I've been thinking should exist but could never find: Filter by Solution.

Consistency in APIs

2009-01-23T09:39:00.001-06:00

One thing that I feel is very important when building APIs is consistency in how method parameters are ordered. Abrams and Cwalina's Framework Design Guidelines talks about this as well.

I came across one instance of inconsistency that is a good example, I think. We're using MSTest for unit testing on our current project and so we make extensive use of it's "Assert" class. For most of the assertions that do a comparison between and expected and actual object, you pass the expected object first. For example:

Assert.AreEqual(Of T)(expected as T, actual as T)

Assert.AreSame(expected as Object, actual as Object)

And now we come to the exception.

Assert.IsInstanceOfType(value as Object, expectedType as System.Type)

When using the assertion for IsInstanceOfType, suddenly it takes the actual object in the first position. This becomes annoying because now I have to remember if I put the actual or expected object first every time I use an assertion method.

Additionally, they've also named the expected object parameter "value" instead of "expected".

So, when building APIs even if you are not planning on publishing them for devs outside of your project, remember to be consistent with parameter ordering and naming. It helps with discovery and adoption of the API.

Splitting PDFs

2009-01-05T12:56:00.001-06:00

Today I needed to split up a PDF and went looking for a tool that would do that for me. I came across the project named PDF Toolkit (http://www.accesspdf.com/pdftk/).

Using this tool I executed the following command and, voila, I had one PDF document for each page in my input document:

pdftk.exe input_file.pdf burst

Check the included .txt file for the full set of command-line parameters.

WCF service blocking when self-hosting (or How The ServiceBehavior's UseSynchronizationContext parameter saved me)

2008-11-14T21:28:00.001-06:00

Today I was working on a feature in our application that uses WCF. We wanted to make it possible to run the service piece in-process or as a service with minimal changes. This is quite easy with WCF using the ServiceModelEx library from the iDesign crew. Simply reference the ServiceModelEx.dll and wherever you'd normally create your WCF client proxy, just use the following code instead:

Dim channel = InProcFactory.CreateInstance(Of TServiceImpl, TServiceInterface)()

However, when I ran this code the first call on the client proxy hung and timed out. I started digging into why it was timing out. Eventually I remembered reading about WCF's ability to use a SynchronizationContext with the ServiceBehaviorAttribute. Essentially WCF will use a SynchronizationContext to manage some of the threading issues that arise from writing a WCF service and/or client. (See more here). It gets even better when you are hosting a WCF service within a Windows Forms application. In that case the WCF service will grab the WinForm SynchronizationContext that manages threading of the UI thread.

It turns out that was exactly my problem. Using the InProcFactory (which uses the Named Pipe binding to host the service implementation in the same process as the client) my service was being hosted in my WinForms application. This caused the default WCF behaviour of attaching to the UI thread's SynchronizationContext to occur. When I called my WCF service, the service blocked because the WCF client proxy was invoked from the UI. When the timeout occurred and the client-side had finished with the UI thread, the service happily proceeded to execute (which was far too late at this point).

The Solution

The solution turns out to be extremely easy. The ServiceBehaviorAttribute can be applied to your WCF service implementation. One of the parameters to that is "UseSynchronizationContext". Set that to false on your service and the service will create it's own SynchronizationContext and your client will no longer block when hosting the service in process.

ServiceBehavior(ConcurrencyMode:=ConcurrencyMode.Reentrant, UseSynchronizationContext:=False)> _
Public Class MyService
Implements IMyService

VB.NET and default values

2008-09-19T10:22:00.001-05:00

A reminder for myself more than anything.

In VB.NET 'Nothing' can be used as the default value for any type. This is the equivalent to 'default(T)' in C#.

This is especially handy when creating generic methods where you want to return the default value for the generic type.

UI Design - What am I moving?

2008-08-22T09:15:00.002-05:00

Here's a UI design snafu that I came across today in Vista.

Can you tell me what the name of the folder I'm moving is? This isn't a big deal for a single move, but when you have a couple of these windows open and you are wanting to cancel one, how do you know which one to cancel. It would have been nice if the title bar or banner said "Preparing to move 'SomeFolder'".

Informative Podcasts

2008-08-01T14:11:00.001-05:00

Over the past 6 months I've started listening to podcasts during my commute to and from work. I've included a list of podcasts that I listen to. If you have others that you find useful/interesting, feel free to post them in the comments. I'll update this list as time goes by as I find new ones of if somebody points one out in a comment.

Imaginet Webcast - Dependency Injection with StructureMap

2008-06-18T12:30:00.001-05:00

I did a webcast today on StructureMap and Dependency Injection. Overall it went ok (except that I forgot to turn on the audio part of LiveMeeting for the first few minutes and had to restart). I've clipped that from the video so you won't have to watch me walk through slides without audio.

You can grab the content using the following links:

Edit (June 25, 2008) - I've uploaded the presentation finally. Note that for the first few minutes I didn't have my audio on. I restarted once I figured that out. It's a bit raw, but after several attempts to re-encode the presentation I decided to give up and just publish it.

If you have any questions feel free to post them in a comment to this post.

IE7Pro - Don't run IE without it.

2008-05-15T09:23:00.001-05:00

If you are an avid Internet Explorer user, one add-in that I'd highly recommend is IE7Pro!

This add-in brings a number of great features to the table including:
- Ad blocking
- Spell checking
- Inline search (This is the same search implementation as FireFox has and after using this the popup search will seem so annying!)
- A whole bunch more!

Do yourself a favour and check it out.

Imaginet Webcast Series (part II)

2008-05-12T21:24:00.001-05:00

Joel has just posted all the details about Imaginet's free webcast series.

There's lots of great content in this series so feel free to take in whatever interests you.

We'll be recording these webcasts and making them available for you to watch whenever you want. As we finish each webcast we'll post the archived URL and "show notes".

Stay tuned for more info.

XUnit.Net's [Fact] and [Theory] attributes

2008-05-08T08:44:00.001-05:00

Following a debate with Dave yesterday I got to thinking (it's a rare event, and I like to revel in it when it happens). There may be technical reasons why you have to use [Fact] for a "regular" unit test (oh, I know it's not a unit test, it's a specification, humour me) and [Theory] for "data driven" tests. But from a usage point of view, why should I care if it's data driven or not? Wouldn't it be nice if the test runner would be able to identify a parameterless method and say "hey, this must be a regular unit test". Also,if the method has parameters it could be smart enough to say "hmm... this must be a data driven test. Do I have any data available?". If the developer hasn't provided any data, then the test, I mean spec, fails.

I think I fall on Dave's side of the argument that this feels like changing somewhat standardized terminology just for the sake of being different (or maybe it's trendy to keep up with the Ruby folks?).

What do you think, dear reader?

Resetting the Administrator password on Windows Server 2003

2008-05-06T12:42:00.001-05:00

At my work we use Microsoft Virtual PC quite extensively. One of the "fun" things about this is that you end up collecting alot of passwords. Normally I just have a text file in the same directory as my virtual images that reminds me what the Administrator password is.

Today I booted an image and could not remember the password. I started Googling and found a few solutions. I finally found one that was able to blank out the Administrator password. The project is called Trinity Rescue Kit. It is a bootable Linux ISO image. Once it boots you simply execute "winpass" and follow the prompts. It gave me some scary warnings saying that the filesystem was in use (because I wasn't able to shut down the image cleanly because I couldn't log in) and because something called SYSKEY was enabled. I forced a mount of the filesystem and that turned out fine. I also choose the default option for the SYSKEY question (which left it enabled) and that in the end I can now log into the VPC.

Hurray for Trinity Rescue Kit!

Setting sort order in Windows Live Messenger History

2008-05-02T16:26:00.002-05:00

I use Windows Live Messenger quite a bit (for personal and work use actually). I find that it's annoying that when I view the message history for a contact that it's sorted with the oldest messages at the top. Most often I'm interested in the newest messages when I go to view message history. Today I decided to change that.

First some background. Windows Live Messenger stores each contact's message history as an XML file in "My Documents" (or "Documents" if you are on Vista) within a folder named "My Received Files\[msnid]00000\History" (where [msnid] is your Live Messenger id and the 0's are some number that changes). Within this folder there is also a file named MessageLog.xsl. This file is used when viewing the message history to format the XML files in a nice format (using an XSL transform).

It turns out that it's very easy to change the ordering of the message history. Within MessageLog.xsl there are several parameters (at the top of the file) that control the layout of the history view. Simply edit the <xsl:variable> named "MostRecentSessionFirst" and set it's value to 1 your messages will now sort in descending chronological order.

<xsl:variable name='MostRecentSessionFirst'>1</xsl:variable>

There's several other <xsl:variable>'s at the top that you can play with. I'd recommend making a backup before starting to play with this file though.

Imaginet Webcast Series

2008-04-30T10:13:00.001-05:00

Several of my colleagues from Imaginet and I will be presenting a series of webcasts starting on May 14th. This series will be pretty broad in what is covered, but in most cases will be very technical (ie. low on Powerpoint, high on code). These webcasts will all start at 11:15 am EST and will be about 1/2 hour each.

If you're looking through this schedule and you have other ideas on what you'd like to see, feel free to leave a comment and we'll try to cover that topic in the future.

Here's the schedule.

Topic	Presenter	Date
Customizing Team System Process Templates	Steve Porter	14-May-08
Introduction to Software Factories	Robert Regnier	21-May-08
Windows Communication Service Gateways with C # 3.0 and Linq-To-SQL	Dave Harris	28-May-08
Testing out the MVC: Routing	Ryan Weppler	04-Jun-08
Customizing Software Factories	Robert Regnier	11-Jun-08
Dependency Injection with StructureMap	Jeremy Wiebe	18-Jun-08
Nhibernate: An Entry-Level Primer	Dave Harris	25-Jun-08
Creating Real world applications with CSLA 3.5	David Maynard	02-Jul-08
MVC vs MVP smackdown	Robert Regnier	09-Jul-08

Random numbers in SQL Server

2008-04-22T09:02:00.001-05:00

I'm putting this here for my future reference.

I sometimes need to generate random numbers (especially when creating test data in a table). Here's a method to generate random values that will work even when used in a set-based action (ie. inserting records into table B using table A as the source).

select RAND(CHECKSUM(NEWID())) * [upper limit]

where [upper limit] is the maximum number you want in your random set.

Unlocking a User Account from Command Line

2008-03-25T12:52:00.002-05:00

Today I fat-fingered a password many times while trying to log into one of our project servers. Our domain accounts have been put into the Administrators group on that server but through Group Policy (or some other mechanism) we cannot load any MMC snap-ins. To get around that we've been given a single local administrator account. That's the account I locked up. I sent off a request to get the account unlocked but being impatient I started looking for a way to unlock a user account through the command line. Here's how (replace <username> with the actual username):

C:> net user /Active:YES <username>

Locating Silverlight 2.0 Assemblies

2008-03-06T08:50:00.001-06:00

Yesterday I started playing with the Silverlight 2.0 Beta 1 bits. I started working through Scott Guthrie's series on working with Silverlight 2. When I got to the point where Scott starts working with Linq-to-Xml I got stumped. I couldn't find the assemblies containing XDocument and XElement. After some browsing around for about an hour I gave up. I looked in %Program Files%\Silverlight\2.0.30226.2\.

This morning I re-installed Silverlight 2.0 and hunted around a bit. I finally found the System.Xml.Linq.dll (the dll containing XDocument) in C:\Program Files (x86)\Microsoft SDKs\Silverlight\v2.0\Libraries\Client. (I'm running Windows Server 2008 x64).

The 3 stages of a password change

2008-01-10T10:34:00.001-06:00

I had a realization today with how I "react" to a password change. At my work we have to change our passwords periodically (I haven't taken note of exactly how often that is!). I find that after a password change I go through 3 stages.

Stage 1: Wrong password.

I find that during the initial few days I type my old password on the first try pretty much every time when trying to log into my workstation or unlock my computer. This is annoying, but it rarely is so bad that I do it enough to lock my account.

Stage 2: Catching myself.

During the second stage I start typing my old password but before pressing <Enter> to log in/unlock my computer I catch myself, delete the characters and type in the new password. This stage again lasts for a few days.

Stage 3: Bliss!

During the last stage I have fully committed my new password to muscle memory and logins/unlocks are smooth and quick!

Overall this isn't too inconvenient but I can't imagine how frustrating it would be if I had to change my password weekly or worse, daily! I might have to look into actually using the HP Biometric Fingerprint Sensor on my laptop for logging in instead of typing in my password. (The downside to that is my coworker uses it and it looks like its even slower than mistyping my password once before getting it right).

Common Log File System and System.IO.Log

2007-09-27T08:45:00.001-05:00

I was poking around the MSDN documentation looking for some Trace information and I stumbled upon the System.IO.Log namespace. I haven't had a chance to work with it yet (and at this point I'm not sure how usable it would be for general application development as it's only available on Vista and Windows Server 2003 R2) but it looks intriguing.

DevX.Com has a nice introduction to it here.

I'm not sure that this will displace my favourite logging tool but competition is never a bad thing (although I have strong feelings about fragmentation, especially in the open source world, just for the sake of "having my own project" but that's content for a different blog post).

Antialiasing Gone Bad

2007-08-22T11:48:00.001-05:00

Antialiasing Gone Bad
Originally uploaded by jeropa

I've changed my VS2005 color scheme to a funky black-background scheme that I found on the net (and then tweaked a bit). I hadn't noticed this before, but today while in the HTML editor the text on the currently selected line looked absolutely horrible. I suspect that it's the antialiasing that is assuming things about my color scheme. Whatever it is (could also be ReSharper but I can't tell) it's extremely annoying and may cause me to switch my colors again.

Update: Turns out the issue _was_ ReSharper. It has a feature called "Highlight current line". I turned that off and problems go away! I've filed a bug with JetBrains.

Humane Interfaces and Primitive Obsession

2007-08-01T10:04:00.001-05:00

I just finished reading a blog post from Martin Fowler on Humane Interfaces. Summed up the term simply means that an API is designed to be useful to a developer instead of being minimal and "legalistic" about what it should include (this is how _I_ understood the post).

I also read Chris Wheeler's "My Favorite Smells" Primitive Obsession blog post yesterday and the while reading Martin's post I had a small epiphany.

Based on Chris's example of array indexes and the confusion over 1 or 0-based arrays, I thought, this would be a place where a Humane Interface could have solved the Primitive Obsession problem in a slightly different way.

Take a bunch of arrays that use a mixture of 0 and 1-based indexes. Chris's solution was to have a ZeroBasedInt and OneBasedInt that were used to index into the array. My idea is that the array's themselves could have simply had a First and Last property (or method).

The code would then simply be:

for (int i=myarray.First; i<=myarray.Last; i++)

{ // do something }

Neat Vista Feature - Copy As Path

2007-07-22T12:13:00.001-05:00

I was trying to get an Explorer context menu set up today for .dll files in Vista so that I could simply right-click on a DLL and select "Register" and have regsvr32.exe register the DLL (as well as a companion "Unregister" menu item).

While trying to figure out how to do this (I'll post a solution when I get there... I've done it in XP but cannot remember exactly how and the way I "remember" it is not working) I came across a neat feature in Vista.

When viewing a folder in Vista's Explorer you can hold down the Shift key and right-click on a file. This brings up a slightly modified context menu from the standard one you get if you don't hold Shift down. Nestled in the menu is a nice little menu item labeled "Copy as Path". When you select this item it will copy the full path of the file (including the file name) into the Clipboard for you.

Handy stuff, I say!

By the way, I stumbled across this while reading Tim Sneath's "Command Prompt Here" blog post... http://blogs.msdn.com/tims/archive/2006/09/18/windows-vista-secret-1-open-command-prompt-here.aspx)

C# ManagementEventWatcher using Win32_LocalTime and DayOfWeek masks (WMI)

2007-06-26T11:35:00.000-05:00

We are using WMI notification events for scheduling activities on our current project. This makes scheduling events on a periodic basis very easy as you don't have to set up timers, calculate intervals to the next event, reset the timer, etc. With WMI events you can simply set up a mask on the local time (or UTC if you prefer) and then whenever that mask matches the system clock you get an event.

We are using Win32_LocalTime for our schedules and we came across a bug in using WMI notification events and the DayOfWeek property on Win32_LocalTime. Turns out that you cannot specify a single DayOfWeek (they number from 0 to 6 where 0=Sunday) on a schedule. WMI simply will not raise an event even when the mask matches.

So, for example, the following query will cause an event to be raised every Tuesday and Wednesday at 3:00 PM (WMI events have a granularity to the second, so no subsecond event notifications):

SELECT * 
FROM __InstanceModificationEvent 
WHERE TargetInstance ISA 'Win32_LocalTime' 
AND 
(
    TargetInstance.DayOfWeek = 2 
    OR TargetInstance.DayOfWeek = 3
) 
AND 
(
    TargetInstance.Hour = 15 
    AND TargetInstance.Minute = 0 
    AND TargetInstance.Second = 0
)

However, if you just want events on Tuesday WMI seems to simply ignore the registration:

SELECT * 
FROM __InstanceModificationEvent 
WHERE TargetInstance ISA 'Win32_LocalTime' 
AND 
(
    TargetInstance.DayOfWeek = 2
) 
AND 
(
    TargetInstance.Hour = 15 
    AND TargetInstance.Minute = 0 
    AND TargetInstance.Second = 0
)

Our solution is to register for every day of the week and then when the event is raised, simply filter it out if we don't really want an event on that day.

The interesting thing is that masking on the day of the month (Day property) for a single day works just fine.

When Dispose() isn't enough

2007-06-21T10:36:00.000-05:00

A while back I had a discussion with another developer on my current project about Dispose() and the need to call an object's Close()/Stop()/etc methods before calling Dispose(). I was of the opinion that classes implementing IDisposable would be smart enough to do whatever cleanup was necessary without the caller needing to also call Close() or Stop() or whatever other method "disables" that object's functionality. He argued that you may not always be able to rely on Dispose() being implemented properly. I came back with the System.Data.SqlClient.SqlConnection object and showed in Reflector that it does indeed call Close() during Dispose(bool). See, I'm right!

Well, today I had to eat my words and agree with him (You were right Dave! :-) ). We use WMI even notifications to raise scheduled events by subscribing to changes on Win32_LocalTime. While trying to diagnose why we sometimes get a "Quota Violation" exception when subscribing I opened up Reflector to look at the ManagementEventWatcher class. The ManagementEventWatcher has a Stop() method which disables event notifications. The bad part is that it inherits from System.Component.ComponentModel (which implements IDisposable) but does not override Dispose(bool). This results in leaking event subscriptions when a Start()'d ManagementEventWatcher is Disposed without first calling Stop().

So, lesson learned... unless you know for sure (ie. you've checked using Reflector), always call the "disabling" method (Stop(), Close(), whatever) before Disposing your IDisposable objects. In a perfect world any object implementing IDisposable would correctly clean up after itself, but in the real world that's not the case!

SQL Server version of 'whoami'

2007-05-31T09:44:00.000-05:00

This is related to my previous post about connecting to SQL Server using integrated security. I needed to find out what identity I was connected as when accessing SQL Server. A quick Google search yielded this SQL statement:

SELECT suser_sname();

Connecting to SQL Server using Windows Integrated Security across domain boundaries

2007-05-31T09:26:00.000-05:00

In the project I'm currently working on we had a requirement to use Windows Integrated Security to connect to a SQL Server 2000 database. The "gotcha" was that the database is on a Windows 2003 Server and a member of a domain. The web server that needs database connectivity is not a member of any domain.

It turns out that it is possible to use integrated security in this scenario if you configure things correctly. You'll need to create local machine accounts on both machines and those two accounts must have identical usernames and passwords.

So, for example we have a SQL Server running on 'mysqlbox' in the 'DEMO' domain and a web server named 'mywebbox' which is not a member of any domain.

1) Create a local user account on 'mysqlbox' named 'testuser' with a password of 'password'.
2) Create a local user account on 'mywebbox' named 'testuser' with a password of 'password'.
3) Configure your application on 'mywebbox' to run under the identity of the account created in step 2 (so mywebbox\testuser). In our case we had a web application so the App Pool that the web app runs under was configured to be 'mywebbox\testuser'.
4) Grant access privileges in SQL Server to mysqlbox\testuser (note that you do not grant access in SQL Server to mywebbox\testuser at any point... that user is not know to the mysqlbox server).
5) Set the connection string for your application to:
Server=mysqlbox;Database=MyDB;Integrated Security=SSPI

At this point your should be able to run your application and connect to the database using integrated security. In the database you will be connected as mysqlbox\testuser even though your application is running on mywebbox as mywebbox\testuser.

Good times.

Parameterized Unit Tests via Pex

2007-03-09T15:36:00.000-06:00

I came across this Microsoft Research via Peli's Farm. This looks like a cool idea at first glance but as I think about it I'm not sure it's a good thing. It definitely helps for parameter validation but I'm wondering if a tool like this may just give developers a false sense of security.

I should qualify that I'm nowhere near a TDD guru (although I _am_ working at it). But how would a tool like this actually be able to verify the desired functionality when the developer doesn't really know what values the method will be called with when the test runs? On the other hand I do know that bugs come out when a method encounters values not anticipated by the developer. Maybe this tool has it's place as a "catch-all" for when the developer has written a bunch of unit tests to cover all the cases that they can think of. They can then "add on" Pex to get that extra bit of coverage and ensure that their code is being exercised fully.

HP nx9420 and Hardware Virtualization

2007-01-29T08:38:00.000-06:00

Over the past month I've been trying to figure out why Microsoft's Virtual PC 2007 RC1 won't allow me to enable Hardware Enabled Virtualization. The Beta of VPC 2007 used to check the "Enable Hardware Virtualization" option checkbox but it was greyed out and beneath the option it said that hardware virtualization was not available on my computer (talk about conflicting...).

I started to do some research. The nx9420 I have comes with an Intel T7400 Core 2 Duo Mobile CPU. So off I go to Intel's site to find that indeed the T7400 supports Intel's VT technology (their version of hardware virtualization). I contacted HP and their tech support stated that the nx9420 DIDN'T support hardware virtualization so I was stumped. I sent the Intel link I'd found to the HP tech support and he still maintained that there was no VT support.

So today I decided to give it one last try. I went to HP's support site looking for driver updates and low and behold there's a BIOS update available for my laptop. I looked at the release notes and to my sheer joy I see that the BIOS upgrade adds support for hardware virtualization.

I downloaded the update (F.19) and installed it using HP's snazzy Windows-based BIOS update utility (which gave me a bit of the shivers thinking I was doing a BIOS update in Windows) and rebooted. At the POST menu I went into the BIOS settings and there's the option! I enabled Hardware Virtualization in the BIOS, booted into Windows Vista, started up VPC 2007, and now I have hardware virtualization enabled in VPC!

Life is good once more.

System.Diagnostics.Process and asychronous output

2006-09-20T12:43:00.000-05:00

The project I'm working on requires interaction with a command-line executable. We have essentially created an ADO.NET data provider on top of this command-line application that retrieves data for us from a proprietary source.

This ends up working quite well except for one problem. The command-line app sometimes pops up a dialog when it encounters an error. On a desktop environment that's not a problem as the user can just hit the "Ok" button on the dialog. However, in a server environment this is disastrous (especially when we're talking about a Windows Service that cannot interact with the desktop).

Our solution was to use the System.Diagnostic.Process objects asynchronous facilities (subscribing to the OutputDataReceived event and then calling BeginOutputReadLine()) to collect output asynchronously and then have a timer that could kill the request if the command-line app didn't return within a specified interval.

Again, this seemed to work well....until we found out that when we blocked on the WaitForExit() call we could return before all output had been received in our event handler.

To work around this you need to pay attention to the OutputDataReceived event's argument object. The DataReceivedEventArgs object has a Data property that contains the data being delivered for the current event. When that property is null (Nothing in VB.NET) the process has finished.

In our class we simply blocked on a boolean flag until the Data property was null at which point we flipped the flag to true and we knew we could return the data we'd collected.

Agile Blog Links

2006-09-05T08:28:00.000-05:00

After not having posted for well over a year, I figured it was time to fire up the blog again. I'm hoping to keep up with this a bit better from now on.

To start off, I've collected a bunch of links to some of the Agile software development blogs (and specific postings) that I've found really good over the last little while.

Jeremy Miller's "Best of" post.

Jeffrey Palermo's Blog.

Brian Button's Blog

James Shore's Blog (Excellent agile blog IMHO!)

There's lots of good stuff out there. This is just a few that I've found that I really like. Feel free to post your "best of" in the comments. I'll update this post as I find new interesting blogs/posts in the comments. :-)

Checkin' out Flock

2005-10-21T08:55:00.000-05:00

I've just downloaded the first Developer Preview of the new Flock browser.

This new browser integrates some nice features for blogging and using sites like del.icio.us... in fact, this post is being created right in Flock!

I've only used it for about 5 minutes, but I'll try to use it more throughout the day and I'll post my take on it if I have time. So far it is neat to use.

Tess of the D'Urbervilles (sp?)

2005-09-16T13:02:00.000-05:00

I sent my buddy Greg a link to the audio book from Project Guttenberg for a good laugh.

As he says here we were in the same English class in Grade 12 and, to use his term, "studied" the book. I'll agree with him that it's a slooooooow book. I think it would appeal to the same crowd that finds "art" in abstract painting... something like the paintings our Canadian government would pay $1,000,000 for but could be painted by a three-year old.

P.S. In case there's some eager reader actually wanting to find this book. Its here.

I got a fever... and the only prescription is more cowbell!

2005-06-23T10:00:00.000-05:00

[Edit: As might be obvious, I don't blog often and when I do they suck! I've updated this post to make more sense. :-)] Ok, so I just watched a clip from SNL with Christopher Walkin and Will Farrell. It features Farrell as a member of the Blue Oyster Cult as they are recording their single "Don't Fear the Reaper" playing the cowbell. Christopher Walkin plays Bruce Dickinson and "can't get enough of the cowbell". What a funny skit.

Some choice quotes:
"Easy guys, I put my pants on just like the rest of you... one leg at a time. Except, once my pants are on, I make gold records."

"I gotta have more cowbell!"

"Guess what? I got a fever...and the only prescription is more cowbell!"

I haven't seen SNL in a long time, but the last few times I did watch it it wasn't as funny as when I first started watching it. The good ole' days with Chris Farley and crew. Some memorable skits include "Livin' in a van down by the river" and "Celebrity Jeopardy". I also really liked some of their pardody commercials.

Direct Manipulation Using JavaScript and CSS

2005-04-27T09:06:00.000-05:00

Tim Taylor has released an updated version of his excellent (and rapidly improving) DHTML library for implementing drag-and-drop features in web applications. I'm currently using the release before this one, but I'm tempted to upgrade just because this release is much more organized now.

Go look: Tim Taylor's Direct Manipulation Using JavaScript and CSS

Javascript, DHTML, Drag-and-Drop

2005-04-18T19:32:00.000-05:00

I've been doing lots of javascript and DHTML stuff lately. I'm working on a project that is really neat ... it's an query builder that allows the user to build a query using drag-and-drop.

While searching for help with javascript and related subjects I've come across several extremely useful javascript libraries, examples:

Sarissa (cross browser XML library)

Javascript drag-and-drop library (Based on a lib by Youngpup)

And an adaptation of that library

Ubuntu, MSN Spaces Logos

2005-04-15T21:31:00.000-05:00

I was browsing around the net tonight and was reading a blog posting that mentioned MSN Spaces (Microsoft's blogging site). I thought I'd check it out and to my surprise I encountered a logo that looked very familiar.

What do you think?

Ubuntu Linux Logo

MSN Spaces Logo

ASP.NET's RegisterHiddenField and document.getElementById

2005-03-16T09:19:00.001-06:00

I was doing some testing today to find out why one of our ASP.NET web apps wasn't working in Firefox. It boiled down to the fact that ASP.NET's Page.RegisterHiddenField() method doesn't set the 'id' attribute of the element it creates, only the 'name' attribute. This in turn breaks Firefox's getElementById because in Firefox (and all other Mozilla-based browsers, as I understand) the id and name namespaces are not merged (as they are in IE). So getElementById() in Firefox will never find a hidden element created by using RegisterHiddenField().

The simple workaround is to use a HTML Hidden Input element as follows in the ASPX page:

<input type="hidden" id="myHiddenElement" runat="server" value="myvalue" />

Then in the .cs codebehind you can declare your hidden element as follows:

protected System.Web.UI.HtmlControls.HtmlInputHidden myHiddenElement;

and you can manipulate the control in the codebehind as follows:

this.myHiddenElement.Value = "some value";

I would consider this a bug in the RegisterHiddenField() but if someone can explain why it isn't, I'd LOVE to hear why.

February CTP Builds of VS 2005

2005-03-04T08:14:00.000-06:00

Microsoft has released the February CTP builds of Visual Studio.

More info here.

I haven't had much time to play around with Visual Studio 2005 yet, but the time I have spent using it was very pleasant. The productivity improvements in the IDE are so nice (refactoring, Intellisense EVERYWHERE, etc). I'm also very excited about the two-way databinding for ASP.NET and the ClickOnce deployment for windows forms.

Giddyup!

Inspecting ViewState...

2005-03-02T09:35:00.000-06:00

I recently stumbled across this handy tool on the 'net.

Page ViewState Parser

It allows you to get a full object graph of whats in the __VIEWSTATE hidden field. It's suprising what's all stored in there. It makes it alot more apparent why most folks recommend disabling ViewState on controls unless you really need it.

Joke: Aerial Photographer

2005-02-23T08:23:00.000-06:00

A photographer from a well know national magazine was assigned to cover the fires at Yellowstone National Park. The magazine wanted to show some of the heroic work of the fire fighters as they battled the blaze.

When the photographer arrived, he realized that the smoke was so thick that it would seriously impede or make it impossible for him to photograph anything from ground level. He requested permission to rent a plane and take photos from the air. His request was approved and arrangements were made. He was told to report to a nearby airport where a plane would be waiting for him.

He arrived at the airport and saw a plane warming up near the gate. He jumped in with his bag and shouted, "Let's go!"

The pilot swung the little plane into the wind, and within minutes they were in the air. The photographer said, "Fly over the park and make two or three low passes so I can take some pictures."

"Why?" asked the pilot.

"Because I am a photographer," he responded, "and photographers take photographs."

The pilot was silent for a moment; finally he stammered, "You mean you're not the flight instructor?"

MCSD: Off and running

2005-02-21T14:04:00.000-06:00

I just wrote my first of 5 MSCD exams (070-316: WinForms C#). I passed and so now I'm going to tackle the ASP.NET C# exam. If anyone has suggestions for books/training kits that are good for exam preperation, leave comments.

Hoowah!

Building Distributed Objects in .NET

2005-02-06T20:05:00.000-06:00

I just got through the VSLive! preconference workshop for Building Distributed Objects in .NET. Rocky Lhotka is an excellent speaker and it was great to hear his real-world, pragmatic views on business objects, DataSets/DataTables, etc. The short story is that business objects are good.

One point that he made that seems obvious in retrospect but seems to be confused by many folks is that even though you organize your code in an n-tier fashion, that doesn't mean that you have to be on many different machines. He even went as far as to suggest that in many cases the classic 2-tier architecture may be fine. *gasp* ;-) I'd tend to agree with that.

Well, that's it for today. I'm really looking forward to the rest of this week and am hoping the rest is as good as today.

Oh yeah... off to watch whatever's left of the SuperBowl! (No, I am not cheering for a specific team.)

VSLive!

2005-02-06T10:12:00.000-06:00

Well, it's the first day of VSLive! I got here early as I'm still on Central time and was up at 6:00 am. There's a neat tablet "hands-on" area as well as wireless internet access. Having never used a tablet before I find them pretty neat. The handwriting recognition on them is unbelievable.

I'll try to post more about the presentations as I attend them. I'm looking forward to learning a ton of stuff about upcoming features in .NET 2.0 as well as learning more about architecture of .NET applications in general.

New to Blogger.com

2005-01-27T09:50:00.000-06:00

I've decided to move my blog to Blogger.com instead of hosting Wordpress on my own "server". I figure it's much easier to maintain a blog if I don't have to worry about security, updates, etc. in addition to posting somewhat regularly.

The good news is I can continue using the excellent w.bloggar for posting.

Note: This has nothing to do with any problems with Wordpress! I found it very easy to install and use. I just don't feel like maintaining something that I can get for free with much less maintenance.

‘which’ for Windows

2005-01-21T14:54:00.000-06:00

Saw this post on Raymond Chen’s blog

A 90-byte batch file to find a program in your current PATH

Good ole Winnipeg, MB, Canada

2005-01-16T08:53:00.000-06:00

Minus40
Originally uploaded by jeropa.

Waking up this morning it felt a little chilly in the house. It wasnât until I looked at the thermometer that I realized why.

Dissecting a C# Application: Inside SharpDevelop

2005-01-03T14:47:00.000-06:00

I saw this on Eric Gunnerson’s C# blog. The book is a dissection of SharpDevelop by the guys who wrote the code.

Go here to grab it.

First Post

2004-12-24T13:00:00.000-06:00

I’ve finally gotten WordPress [Edit: I moved to blogger after string out into the blogging world as I really didn't want to bother with comment spam, etc. on my own host. ] installed. Sure has a nice interface.

Anyways, down to business. I’ve been batting around the idea of blogging for quite some time now. Now’s the time when I jump in. (A few days short of a New Years Resolution no less.)

As to the content, I’ll be posting (hopefully) lots of stuff about Visual Studio .NET, the .NET Framework (v 1.1 and 2.0 mainly), C# language stuff, and other things developer/hacker related. It may/may not be useful.