Jay Flowers

Switching Blogs

2006-04-25T20:51:00.000-05:00

I have moved my blog to WordPress hosted at jayflowers.com.

Scratching the Itch

2006-04-20T21:17:00.000-05:00

In my last post I explained a way to integrate nAnt into the IDE allowing a nAnt script in the editor or the solution explorer to be executed with a shortcut key. I find this to be similar to macros and the command window, really somewhere in between the two. Not quite as formal as a macro yet far more powerful than the command window. This statement needs some support by itself you will most likely disagree with me. I mentioned self contained projects in the last post and this is where I will start to support my statement. Here is screenshot of the same project I was using as an example last time.

Notice the Packages directory is expanded. It contains nAnt targets for all sorts of functionality. The folder selected, VS.NETCompile, contains functionality related to compilation and VS.NET. Below is the scratch file that was in the background of some the screenshots from the last post.

<?xml version="1.0" encoding="utf-8"?>
<project xmlns="http://nant.sf.net/schemas/nant.xsd" name="scratch" default="test" basedir="..\Build" >
    <loadtasks assembly=".\nAnt\bin\NAnt.Contrib.Tasks.dll" />
    <property name="CCNetLabel" value="Dev"/>
    <property name="CCNetProject" value="Doubler"/>
    <property name="Compile.ConfigName" value="Release"/>
    <include buildfile="Properties.build.xml"/>
    <include buildfile="Common.Build.xml" />
    <include buildfile=".\Packages\Deployment\Deployment.Target.xml"/>
    <include buildfile=".\Packages\VS.NETCompile\Compile.Target.xml" />

    <target name="test">
        <property name="Compile.ConfigName" value="release"/>
        <property name="Compile.Bin" value="${ProductDirectory}\ReleaseBin" />
        <property name="Compile.ToCopyToBin" value="true" />
        <property name="Compile.ToDeployZip" value="true"/>
        <property name="Compile.ZipFileName" value="Doubler.zip"/>
        <delete>
            <fileset>
                <include name="${Compile.Bin}\*.*"/>
            </fileset>
        </delete>
        <call target="Private.Compile.CopyToWorkingBin" />
        <call target="Private.Compile.DeployZip" />
    </target>
</project>

This script will copy files compiled under the release configuration to the ReleaseBin and make a zip file name Doubler.zip, this is something that happens during the build. I can tap into those build scripts calling just the bits and pieces that I need to accomplish a task. The build scripts become a library of targets that I can call on; similar to tasks but providing functioality at a higher level. And there it is, the support for the statement that nAnt scratch is more powerful than the command window and not as formal as macros.

nAnt Scratch

2006-04-18T22:03:00.000-05:00

I love nAnt. It can do so many things for me and I can get it to do those things for me so very quickly. I do not like to leave the IDE, I try to keep the list of reasons for my leaving it short. To help me keep that list short while still getting nAnt to pull it weight I have integrated nAnt into the IDE through the external tools feature of VS.NET. This not a brainy thing. I bet plenty of people have done it. But I don’t see many and more people should. Take a look at how I use it. First I keep a scratch file as a solution item: Scratch.build.xml. I edit this file to do repetitive tasks for me.

While I have the scratch file in focus I execute the nAnt external tool.

To get nAnt to show up as an external tool configure a new external tool like so:

Some shops have self contained projects, meaning that everything the project needs to build is contained in its directory structure. I follow this practice so nAnt is located in the project environment not in my machine environment. This is important to note if you follow this practice too. How will VS.NET find the nAnt.exe. You don’t want to configure a path to a specific projects copy of nAnt. I use bat files to start my IDE.

This OpenSolution batch file will set the PATH to include nAnt.exe.

set PATH=%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;C:\Program Files\Subversion\bin;..\Build\nAnt\bincall "C:\Program Files\Microsoft Visual Studio8\VC\vcvarsall.bat"devenv "Doubler.sln"

You may have noticed the RunScratch batch file as well. This for situations when you need to call devenv.exe from the nAnt script. For some reason it will not compile a lick from the commanline if the IDE is open. I don’t know why.

Something more we can do to make this easier is map a control key sequence to execute the nAnt script. All external tool entries have a VS.NET command. Look in the registry to find the external tool number. On my machine nAnt is 2.

I mapped mine to Ctrl+Shift+N.

CCNET Artifact Directory

2006-04-12T20:11:00.000-05:00

How to publish xml files for use by xsl with out merging into the ccnet build log using nAnt, xsl, and an IIS virtual directory.

Click to watch

P.S. When I say archive I mean to say artifact.

A collection of nAnt goodness

2006-04-11T08:51:00.000-05:00

I have been accumulating nAnt tasks, types, and functions for a while. I had asked on the nAnt dev group if they would like to include them but received no response. The list seems to go through periods where users submit patches and enhancements but I see no evidence of the project leader(s) integrating them into the code line. The project has not released in quite a long time. So I have decided to release some nAnt extensions of my own. A link to the release page can be found on my home page jayflowers.com. Below is a quick example of some of the tasks, types, and functions.

MbUnit Extensions

2006-04-08T20:53:00.000-05:00

I created a custom fixture extending MbUnit some time ago. I am just now getting around to releasing it. I thought about contributing it to the MbUnit project but then people would only be able to use it with the next release of MbUnit on, not previous releases. So here is the silly little home page for it. I made a quick video of using it on a real life project from my work. Yes we use this at my work so that should inspire some level of trust.

Click to watch

nAnt id and refid

2006-04-07T18:45:00.000-05:00

Too often I see delimited strings being passed around in nAnt scripts and not often enough data elements. The id and refid of data elements let you reference it. Below is a fileset with its id set.

The id can be reference later in the script like so:

Unfortunately I see strings being used like so:

Even worse:

I wish that more tasked used data elements so that refids could be passed around. Any thing that takes more than two attributes should consider accepting a data element instead of the attributes and three or should just pain do it. When witting a task to use data elements be sure not feel the need to create just one data element. Group that data that needs to be passed in to logical sets and create a data element for each set. For example I have create PVCS Tracker tasks. One is a task named trackerchange and needs a ticket id number (scrid), server connection information, and what fields to change to what new values.

This design allows for scripts like:

Notice that the connection information is referenced four times and only one line for each. This far more readable than using properties and attributes. It is easier to maintain as well.

Back in the Saddle

2006-04-07T06:15:00.000-05:00

So I kinda dropped of the face of the blog sphere back in December. I had to focus on Family and work. The situation seems to have changed on both fronts so you should see more of my effort in my blog and my web site.

Shell Magic and Shell Extensions

2006-03-22T10:07:00.000-05:00

I had been looking for Windows Explorer like controls for some time when I came across Sky Software’s Shell MegaPack.Net. I particularly need the FileView control. They offer several other products as well: Shell MegaPack ActiveX/Shell MegaPack.Net/ EZShellExtensions.Net. They integrate well into the VS.NET IDE (all editions). I will try to get the FileView into my Doubler product shortly. I am keen to see what could be done with the EZShellExtensions.Net as well.

http://www.ssware.com/

CI Factory

2005-12-08T23:01:00.000-05:00

So I have just finished with the first version of a new product. It is a canned CI server and installation script. I have boiled down what should vary in any given software development organisation's projects’ CI servers to the project name and the port that CCNET will use. It uses a plugin architecture, notice the Packages directory.

The current feature set includes support for:

Visual Source Safe
Assembly and product versioning
PVCS Tracker
.NET Visual Studio 2003 solution compilation
Unit Test execution with MbUnit
Deployment artifact publication
Install Shield or VS deployment packages

I hope to have support for Subversion, Jira, Java, jUnit, CoverageEye, nDepend, FxCop, and Simmian soon. Each project has two CCNET projects a light and a heavy one. A light build is short and a heavy build is long. The light build is set to trigger off source control and the heavy build is a scheduled event. A little bit further down the road I hope to have a dashboard that includes reports trending the data generated in the build. Morten has been kind and offered to host a Confluence space and Jira project for the product. After Berlios gets back to me on the project creation I can set up a SubVersion repo. In the meantime you can experiment with an alpha. Edit the Arguments.xml (or not) and run the Install.xml (nant -buildfile:Install.xml). It expects that the directory “C:\Source Safe DataBases” specified in the Arguments exits. You will need to have Visual Source Safe installed as it creates a new one. The “Admin” user’s password is “” and there is one more user “build” with password “password”. After the install script completes, 20 to 30 secs, run the C:\Projects\TestProject\Current\Build\CCNETServer.Bat file. The initial build should be successful. You can get to the web page at http://localhost/TestProject. There is no documentation at the moment but this is the first release. If all goes well you should see a rapid progression to a more complete product.

Code Camp

2005-11-05T11:08:00.000-05:00

I will be giving two presentations at the Hampton Roads Code Camp in December. The first presentation will be on OOP Exception Handling and the second on MbUnit.

Object Oriented Exception Handling

This session will cover extending structured exception handling into
an OOP solution. Reflection and polymorphism will be used to achieve
this result. A good understanding of polymorphism will be helpful to
attendees.

MbUnit

MbUnit is an advanced .NET xUnit Framework. This session will cover
some of the more interesting fixtures provided by the product and a
few custom extensions.

Testability: Internal State Collapse

2005-10-09T10:44:00.000-05:00

So I have started research for a book that I would like to write. I am currently looking for a metric or metric that will indicate when a design is not very testable. I came across an interesting concept, internal state collapse. This is where the input parameters are not released from the member. For example:

public interface IWarehouse
{
    bool HasInventory(InventoryItem inventoryItem, int amount);
 
    void Remove(InventoryItem inventoryItem, int amount);
    void Add(InventoryItem inventoryItem, int amount);
}

The members Add and Remove do not release amount or inventoryItem. This is known as internal state collapse. The interest here is that it is very difficult to test. Lets examine this a little closer.

public void Add(InventoryItem inventoryItem, int amount)
{
    if (this.HasInventory(inventoryItem, amount)) 
    {
        this.Inventory[inventoryItem] = (int) this.Inventory[inventoryItem] + amount;
    }
    else
    {
        this.Inventory[inventoryItem] = amount;
    }
}

No surprises there. Some people might say “well just use HasInventory to verify that Add was successful”. This is fine in production code but test code should try not to use production code to verify production code. What if there was a bug in HasInventory? When trying to test Add I don’t want to get sidetracked by a bug elsewhere in the product. So the problem is that the information needed for verification is not accessible or in other cases has vanished. After more research I found an answer:

public void Add(InventoryItem inventoryItem, int amount)
{
    if (this.HasInventory(inventoryItem, amount)) 
    {
        this.Inventory[inventoryItem] = (int) this.Inventory[inventoryItem] + amount;
        System.Diagnostics.Debug.Assert(this.Inventory[inventoryItem] > amount, "The inventory should be more than the amount that was just added.");
    }
    else
    {
        this.Inventory[inventoryItem] = amount;
        System.Diagnostics.Debug.Assert(this.Inventory[inventoryItem] == amount, "The inventory should be that same as what was just added.");
    }
}

This feels a lot like a stint to me. The assertions act as stints allowing the verification while maintaining encapsulation. I have seen other solutions that offer information through public members that are conditionally compiled (i.e. encapsulation is only broken for testing). Any kind of solution that breaks the rules just to achieve testability is a lazy solution in my book (that is the bad kind not the good kind of lazy). I doubt that the inventors and practitioners of those solutions hold OOP values and principles. They certainly are not practising them.

Anyway I hope to have the time to finish up the research into testability metrics here in the next two weeks. If you are interested in this kind of thing you can keep track of my progress in more detail at JayFlowers.com.

State Based UnitTesting, or Not?

2005-10-01T10:08:00.000-05:00

I have been doing a lot of research lately on how to teach unit testing. There seem to be to basic forms: State and Interaction. In my last post I define what a unit test is in a very strict way. By that definition I can not see how state based testing is unit testing. I wanted to refer to my own examples here but gotdotnet user samples take 72 hours or so to be published so I will refer to Martin Fowler’s Mocks Aren’t Stubs. At the beginning of this article he illustrates the two approaches. For state based testing to be performed a portion of the system, more than the test subject, was needed. It was needed for the test subject simply to be used. Sniff Sniff Sniff. Do you smell that. Smells like tight coupling to me. Bugs in the warehouse class can easily cause the order unit test to fail. This fail to express much of the potential value of a unit test. Indicating were the problem is. Now we can only know that when a unit test fails that it's a problem in either the order or warehouse classes. So why would I write a separate unit test for the warehouse class, I don’t really even feel like adding asserts to the order test to verify that the warehouse object is in the expected state. All this leads me to believe that state based testing is not a unit testing style at all. It promotes bad practices. This is not to say that it isn’t a great style for other forms of testing, just unit testing. Interaction testing on the other hand is dependent on loose coupling; same as the definition in the previous post depends on it.

Understanding Unit Testing

2005-09-18T22:11:00.000-05:00

Unit testing seems to be one of those topics that will get people to arguing. What is a unit test? What value do they bring? How much time do they add to a project? You can’t write unit tests to test our code. And on and on… I think these questions continue to be asked because they are generally not answered well. To end this we need to find hard and fast answers to these questions. It is hard to argue for something if people can’t even agree on what it is.

u’nit test (noun) : An automated test, exercising a class, verifying that the class fulfills its responsibilities.

This is the absolute minimum needed for a definition of unit test. From here there could be many discussions about nice to haves with this definition (i.e. readability of the tests, naming of the test). Let’s examine this definition.

A unit test is not a unit test unless it is automated. If it is not automated then you must be using a debugger to step through a class to verify that it fulfills its responsibilities. This is a poor practice. It increases the viscosity of your environment; people will be less likely to perform this manual test every time it is needed. With automation thousands of unit tests can be run very quickly while thousands of manual tests will take a very long time. With out automation unit testing is next to worthless. The affect of unit tests is greater than their sum. To gain their full value all must be executed.

A unit test exercises just one class. What does this mean? Let’s say I have class Responder that needs to be tested. Responder has little public interface to speak of. The real meat is accessed by sending Responder messages through the file system. Verifying that Responder meets its responsibilities is also performed by receiving messages through the file system. Responder does not read and write messages to the files system itself, it uses a class called Tunnel. The temptation is to write a test that creates a Responder and rights and reads files to complete the test. Two thirds of what could go wrong is in the tunnels. There is more than one class being exercised. With a little redesign we can add some abstraction in to allow us to exercise just Responder. Exercising more than one class is an integration test.

A unit test will verify the subject class fulfills its responsibilities. As with exercising just one class a unit test is responsible to verify the responsibilities of just the subject class. When you are tempted to assert that an obligation of a class other than the subject is satisfied you are probably exercising more than the subject class. There should be unit tests for those other classes where their responsibilities are tested.

There are other levels of testing (integration, system…) where interactions are tested. Unit tests are mainly about testing the responsibilities of a class.

Naturally people feel exposed if the only tests on a system have tested the individual parts (other levels of testing should be exercised). What value is there in testing each part separately? It eliminates some of what you have to suspect when there is a bug. Unit tests have an affect on the code they test. The obvious affect is more reliable code. Some of the less obvious affects are loose coupling and ability to deal with change. This translates to the stakeholder as the project is more responsive to there needs as they figure them out. We all know that what is asked for at the beginning of the project and what is asked for by the end of the project can be very different things. Unit testing provides a means to balance these opposing forces: refactoring. It facilitates stepped, fine grained, or low level refactoring. With out true unit tests refactoing is a tricky business. In fact if your customer is asking for a change and you have good unit test coverage of your product the tests can be used to illustrate the risk involved with the change (i.e. before the change is applied X of Z tests are passing, after the change is applied Y of Z are passing).

If you are diligent there are other benefits to unit tests as well. Unit Tests can be, when written well, used as developer documentation. They can serve as executable design artifacts (similar to FiT tests). As a coach or architect they can be invaluable for identifying tangles, clutter, and bad or missing design.

When I here we can’t write unit tests for our code I think you don’t know how to use the tools of OOP. I have yet to come across a design problem that can not be solved with OOP to allow for simple and easy testing. It gets difficult when the subject code can not or will not be changed. Most times in these cases there is no simple easy way to create unit tests. Depending on the situation change may be necessary to create unit tests. Many times it is simply taking the time to do the right thing (i.e. creating an Object Mother). I think something that would go a long way to answering this question cold would be a set of patterns for common testing problems.

I think the most difficult question I have encountered is “How much time do they add to a project?”. I don’t think this question can be answered well in a general way. I think that for it to be affective it must address the specifics of the project(s) the questioner is thinking of. There are many variables and possible responses to the affects that unit testing will have on a project. Some developers get it right away, others take longer to understand how to practice TDD. It will reduce the amount of time spent debugging, and debugging is a laborious task. It will reduce the amount of bugs and recursion reaching the test team. The rapid feedback given to the developers should reduce the time needed to produce a feature or fix a bug. They no longer need to wait for the test team to perform verification to gain confidence that they have completed the task (and with the added bonus of not breaking anything else). The short simple (and some would say lame) answer is “Over the course of the project they will not add time but reduce the time needed”. The trick in the answer is “over the course of the project”. I would respond to that answer with “When will I first see the time savings?”. I am not sure I can win this line of questioning yet. It will invariably head to asking for a quantifiable or measurable difference: something tangible. The only way to kill this one is to find a way to make this question moot.

One of the interesting things about this last question is how it tempts me (and would guess others) to bring in other agile practices to the conversation. I am not sure if this is a good or a bad thing. There is defiantly a strong relation to other agile practices: refactoring, Continuous Integration, Continuous Design… At first I feel that their inclusion will bolster the case for unit tests and provide insight into their value. By including them in the discussion their value now seems to depend much on these other practices.

Continuous Design: Were did design go?

2005-09-18T09:24:00.000-05:00

I think there is a parallel between what FiT is doing for requirements and what unit tests can do for Continuous Design. Specifically FiT provides executable requirements and unit tests provide executable design artifacts. Grant-it you must write your unit tests to be communicative. Those migrating from BDUF often feel insecure without design artifacts. There are many other things that make those migrating from BDUF feel insecure but I think this one can be solved by overloading the purpose of unit tests. Viewing unit tests as design artifacts can be a specially helpful at a shop where pair programming is not practiced. Design reviews are the counter to pair programming in the non-agile world, and unit tests could be used to review the proposed design. Having the design expressed as executable tests instills much more confidence in me than design artifacts like documents and diagrams. I can have greater assurance that the design I am reviewing will actually come to be. As well I am assured that the design artifact will stay in sync with the product. So there is an extra step between red and green when not practicing pair programming, design review by examination of the unit tests. Something to be careful of in these design reviews: reviewers are likely to think ahead to the future. The reviewers need to adhere to "Do the Simplest Thing that Could Possibly Work" and "You Aren't Going to Need It". Where interaction between entities larger than classes need to be reviewed FiT tests and fixtures can be included in the review. They should probably be included in the review anyway. If a shop can make this practice work it should save time. Instead of producing both tests (unit and FiT) and design docs they need only create the tests. The quality of the altered process should be the same if not better. The previous process being: create design artifacts, design review, red, green. Notice the lack of refactor? That is because there was a design specified up front, and the goal is to implement that design. The goal of the design was to adhere to "Do the Simplest Thing that Could Possibly Work" and "You Aren't Going to Need It” while expressing the new feature. Refactoring is done in the design phase.

Continuous Design and Values

2005-09-11T10:00:00.000-05:00

So I have always thought that BDUF was flawed. I never enjoyed it, something just felt wrong. Over the last year I have been participating in agile experimentation at my work. For most new features we would have to document a design (UML and text) and hold a design review before proceeding to create unit tests. What was the purpose of these design reviews? To make sure that the implementor was going to express the values held by the architect in the code. It’s not that the developer was not trusted to fulfill the requirement, they were not trusted to hold and express the values of the architect (In this case the values are of OOP). So this indicates to me that the design documentation and review are to direct the implementor as to how they will fulfill the requirement.

I was very attached to this project and its success. I would monitor the CCNET server and review most every change made to the product. When I saw that the design was going astray I would talk with the author of the disruptive change to see what could be done to right the design. In monitoring the product in this fashion I found that design documentation and review were rarely translated into the expected code. This says to me that no amount of direction can get a developer that does not understand and or hold the desired values to produce code that adheres to them.

So I am sure you are asking how does this relate to Continuous Design. Well I don’t have a solution to how to get good code out of developers in opposition to the desired values. It feels like to me that Continuous Design has something to offer here. You might be saying use pair programming. Well that just seems like one developer (the one with the understanding) is doing all the work and the other developer (the one lacking understanding) is getting trained (if they are open to it). That doesn’t really sound like pair programming to me (maybe I don’t understand pair programming well?). At any rate I like Continuous Design better that BDUF. I think it is more productive. It reminds me of the Ron Jeffries quote:

"If I've got six months to build a system, then I'll spend six months building it. I'll also spend six months designing it, and another six months testing it. The good news is that it's the same six months".

Listen When You Can't Read

2005-09-06T14:34:00.000-05:00

So I have recently moved. Before the move I had a ten minute commute, now I have an hour and fifteen minute commute. To fill the time with something besides music I began listening to .NET Rocks. Listening to two .NET Rocks episodes a day is a bit much. I need a little more variety.

I have a list of papers, articles, and books that I have being meaning to read forever. It was almost the perfect time to get to them, the commute that is, except that I had to keep the car on the road. What I needed was someone to read them to me, like my laptop. So I went looking for a text to speech engine. I found plenty and chose AT&T’s PleaseRead. I liked it best for its record to MP3 feature. Now I have two and a half hours a day to listen to all that reading material that has been piling up.

A New View

2005-08-27T08:27:00.000-05:00

We are finally getting settled in after the move. Here are some pictures of were we live now. I love the view of the mountain. I should start blogging more soon. We are going on vaction soon so after that you will see more.

WinProTeam

2005-08-02T20:24:00.000-05:00

I will be presenting at the WinProTeam .NET user group tomorrow on OOP Exception Handling. I have cleaned up the ASOGS code and released it for this presentation. There is not a lot of new stuff but there is some.

Flex

2005-08-01T19:18:00.000-05:00

I created a new CI server in 50 minutes this evening. Started from a blank folder, ended with a successful build showing an install link on the build page as well as PVCS Tracker integration. I rock (I am flexing at this point)! I need to document and share this process, as it is repeatable. I promise I will do this in a future post. I am moving in the next few weeks. So it may be a few weeks before I can share this in a meaningful way.

A Wonderful Quote

2005-07-26T20:37:00.000-05:00

I picked this up from Peli today.

Le trop est l'ennemi du bien

Too much is the enemy of enough

I love it!

Fit Book

2005-07-26T20:30:00.000-05:00

Brian Marick has an interesting write up on the reasons to use Fit. It looks like this was brought on by the release of the new fit book: Fit for Developing Software. This tool one of the best ways to cause a natural move to agile in a project.

Ticket Systems and CI

2005-07-26T20:11:00.000-05:00

I have noticed that most of the people and organizations that preach the virtues of Continuous Integration (CI) also preach the virtues of a good ticket system (Jira is a good example). What I find interesting is that no one, to my knowledge, has integrated a ticket system with CI. If you have a ticket system that records all your requirements as well as your bugs doesn’t that describe all the work to be done to your code? Lets say it does. Could the CI server integrate with the ticket system similarly to the source control system? Well of course it could, but what does that buy you? So lets say that a developer must submit a ticket and code to the build. There would be an association between the code submited to the source control repo and the ticket used to task the developer. This association would be used to aquire information on this ticket in the build script and include it in the build log/report. Besides displaying what ticket was completed with that build the build script can update information in the ticket. It could change the assignee, add a note, change the status, or any number of things. At my work we have the build script move the ticket(s), in PVCS Tracker, to the test team and add a note with information on what build the ticket was sucessfully built in. On the MbUnit project we are in the process of integrating Jira in the same fashion. It seems to me that the ablility of a build script to associate a ticket with a change and manipulate that ticket is a very powerful thing. I find it interesting that I can not find this is kind of thing going on else where.

A Push for FitNesse

2005-07-19T19:34:00.000-05:00

I have been trying to push for FitNesse to be adopted one of the projects I am helping. We have an aggressive schedule that does not allow for the time that the Test team is asking for. I have suggested FitNesse as means to reduce the total time to complete the same if not more testing. In an effort to help the developers on this project who will use FitNesse and in trying to show an example to the Test lead I have created a test fixture that should be able to test any data structure. [[Breathe]] You can test a data structure in one or more table. I sugggest at least two: one for specifying the data structe and housing assembly, the second for testing the data structure.

The AsseblyLocation and the type of the class to be tested, SubjectType, are specified. The next table will use the class specified in the previous table (i.e. SimpleDataStructure will be tested). This table shows test procedures for testing SimpleDataStructure.

The Name column specifies the name of the property in the SimpleDataStructure that wil be tested on this row. The ValueType column specifies the type of the value that will passed to the property. The SetValue column specifies the value to be passed to the property. The ExceptionThrown column specifies to expect an Exception. Notice the question mark. The GetValue column specifies the value that should be in the property. The ExceptionType column specifies the type of Exception thrown, if none enter null. I have included the code for the fixture TestSimpleDataStructure. You can use it as is to test any data structure, well almost. The method CastBoxedValue should be beefed up a bit. It can only handle string and integer right now (if someone knows a better way than a select case statement tell me how). Enjoy :)

Imports fit
Imports System.Reflection
 
Public Class TestSimpleDataStructure
    Inherits ColumnFixture
 
    Private _AssemblyLocation As String
    Private _SubjectType As String
 
    Private _Name As String
    Private _ValueType As String = "string"
    Private _SetValue As String
    Private _ExceptionThrown As Boolean = False
    Private _ExceptionType As String
 
    Public Property AssemblyLocation() As String
        Get
            Return _AssemblyLocation
        End Get
        Set(ByVal Value As String)
            _AssemblyLocation = Value
            If Not Me.SubjectType Is Nothing Then
                Me.CreateSubject()
            End If
        End Set
    End Property
 
    Public Property SubjectType() As String
        Get
            Return _SubjectType
        End Get
        Set(ByVal Value As String)
            _SubjectType = Value
            If Not Me.AssemblyLocation Is Nothing Then
                Me.CreateSubject()
            End If
        End Set
    End Property
 
    Private Sub CreateSubject()
        AddHandler AppDomain.CurrentDomain.AssemblyResolve, New ResolveEventHandler(AddressOf Me.assemblyResolve)
        Me.Subject = Activator.CreateInstanceFrom(Me.AssemblyLocation, Me.SubjectType).Unwrap
        RemoveHandler AppDomain.CurrentDomain.AssemblyResolve, New ResolveEventHandler(AddressOf Me.assemblyResolve)
    End Sub
 
    Private Property Subject() As Object
        Get
            Return Me.Recall(Me.GetType.Name)
        End Get
        Set(ByVal Value As Object)
            Me.Save(Me.GetType.Name, Value)
        End Set
    End Property
 
    Public Property ValueType() As String
        Get
            Return _ValueType
        End Get
        Set(ByVal Value As String)
            _ValueType = Value
        End Set
    End Property
 
    Public Property Name() As String
        Get
            Return _Name
        End Get
        Set(ByVal Value As String)
            _Name = Value
        End Set
    End Property
 
    Public Property SetValue() As String
        Get
            Return _SetValue
        End Get
        Set(ByVal Value As String)
            _SetValue = Value
            Try
                Dim params As Object() = New Object(0) {Me.CastBoxedValue(Value, Me.ValueType)}
                Me.Subject.GetType.GetProperty(Me.Name).GetSetMethod.Invoke(Me.Subject, params)
            Catch ex As Exception
                Me.ExceptionThrown = True
                Me.ExceptionType = ex.GetType.Name
            End Try
        End Set
    End Property
 
    Public Property ExceptionThrown() As Boolean
        Get
            Return _ExceptionThrown
        End Get
        Set(ByVal Value As Boolean)
            _ExceptionThrown = Value
        End Set
    End Property
 
    Public ReadOnly Property GetValue() As String
        Get
            Return Me.Subject.GetType.GetProperty(Me.Name).GetGetMethod.Invoke(Me.Subject, Nothing).ToString
        End Get
    End Property
 
    Public Property ExceptionType() As String
        Get
            Return _ExceptionType
        End Get
        Set(ByVal Value As String)
            _ExceptionType = Value
        End Set
    End Property
 
    Public Overrides Sub Reset()
        With Me
            ._ExceptionThrown = False
            ._ExceptionType = Nothing
            ._Name = Nothing
            ._SetValue = Nothing
            ._ValueType = "string"
            ._AssemblyLocation = Nothing
            ._SubjectType = Nothing
        End With
    End Sub
 
    Private Function CastBoxedValue(ByVal StringValue As String, ByVal NewType As String) As Object
        Select Case True
            Case NewType.ToLower = "integer"
                Return Integer.Parse(StringValue)
            Case NewType.ToLower = "string"
                Return StringValue
        End Select
    End Function
 
    Private Function assemblyResolve(ByVal sender As Object, ByVal args As ResolveEventArgs) As [Assembly]
        Dim chArray1 As Char() = New Char() {","c}
        Dim text1 As String = args.Name.Split(chArray1)(0)
        Dim text3 As String
        For Each text3 In IO.Path.GetDirectoryName(Me.AssemblyLocation)
            Dim text4 As String = IO.Path.Combine(text3, String.Format("{0}.dll", text1))
            If IO.File.Exists(text4) Then
                Return [Assembly].LoadFrom(text4)
            End If
            text4 = IO.Path.Combine(text3, String.Format("{0}.exe", text1))
            If IO.File.Exists(text4) Then
                Return [Assembly].LoadFrom(text4)
            End If
        Next
        Return Nothing
    End Function
 
End Class

Reuse

2005-07-19T19:20:00.000-05:00

I am trying to start a reuse process at my work. I recognize there are different level of reuse.

Copy and Paste
Class
Library
Project
Pattern
Design
Architecture

The tool Koders seems to help a good deal with the first four. The last five seem to need a formal process to achieve. At the moment a board of 4 to 8 people meeting once a month to review submissions to the reuse repo seems to be the answer. If that is the course of action I need: A web site to publish the reusable artifacts to. Criteria to judge a submission by. Requirements a submission must meet. And all the things I have not thought of yet. :)

First Article

2005-07-19T19:16:00.000-05:00

I have published my first professional article.

Unit Testing in .NET Projects by Jay Flowers and Andrew Stopford -- Now is a pretty exciting time for unit testing in .NET. Tremendous progress is being made on several fronts: IDE integration, process integration, and new test fixtures. Jay Flowers and Andrew Stopford explain how to use Visual Studio's new integrated unit testing, as well as the NUnit and MbUnit testing frameworks.

Equal Access HashTable or a Map

2005-07-02T08:44:00.000-05:00

There are many occasions where a Hashtable just doesn’t cut it. You need an object to hold pairs of objects. You need to be able to retrieve either of the members of the pair with the other member of the pair. HashTable just won’t cut it. You can access one member of the pair, the value, with the other member of the pair, the key. You may not access the key with the value. Many times that is exactly what I need. So I got tiered of iterating through the keys looking for the one I needed. I made a new class implementing the IDictionary interface called Map, as well as creating the class MapBase. The following example with use MapBase to illustrate.

Lets say that we have a list of Names and IDs. We would like to be able to use either the name of the id to retrieve the other.

public class NameIdMap : MapBase
{
    public int this[string Name]
    {
        get
        {
            return (int) this.MappedTable[Name];
        }
        set
        {
            this.MappedTable[Name] = value;
        }
    }
 
    public string this[int ID]
    {
        get
        {
            return (string) this.MappedTable[ID];
        }
        set
        {
            this.MappedTable[ID] = value;
        }
    }
 
    public void Add(string Name, int ID)
    {
        this.MappedTable.Add(Name, ID);
    }
 
    public bool Contains(string Name)
    {
        return this.MappedTable.Contains(Name);
    }
 
    public bool Contains(int ID)
    {
        return this.MappedTable.Contains(ID);
    }
 
    public void Remove(string Name)
    {
        this.MappedTable.Remove(Name);
    }
 
    public void Remove(int ID)
    {
        this.MappedTable.Remove(ID);
    }
}

The class NameIdMap will allow this. 50 braindead lines of code and you have type safe access to your map. If didn’t want type safe access you could have used a Map.

public class JustUseAMap
{
    public void Example()
    {
        Map NamesAndIDs = new Map();
 
        NamesAndIDs.Add("Jay", 1);
        NamesAndIDs.Add("Andy", 2);
 
        if (!NamesAndIDs.Contains("Jay"))
            throw new Exception();
 
        Console.WriteLine("Jay's id is {0}", NamesAndIDs["Jay"]);
    }
}

If this is something that could improve your day it’s part of the ASOGS project.

New OOP IRC Channel

2005-06-28T11:10:00.000-05:00

Well after much looking I have been unable to locate an existing IRC Channel for Object Oriented Programming. In response to this deficiency I have create just such a channel #Object. I hope to see you there.

External Polymorpism

2005-06-26T09:40:00.000-05:00

So I have been posting an awful lot about oop exception handling. The approach that I have been following makes use of external polymorphism. As far as I can tell Chris Cleeland and Douglas C. Schmidt were the first to document its use as a pattern. They implemented with templates in C++. An OOP language with reflective abilities can achieve a similar effect. Before we dive into the implementation lets get some context, get on the same page as to what we are trying to solve.

Allow classes unrelated by inheritance or related by inheritance but without the desired virtual method to be treated polymorphically.

If you read the paper Douglas and Chris wrote my last sentence should sound familiar. Now a little motivation would be nice too.

Say I found that the best solution for my problem was to implement the Visitor pattern but the class that I would need to alter are not in my control. They are classes that have been purchased in a third party library.

I want to focus on explaining the implementation not on justifying the need for this pattern. Justification is worth at least a whole other blog entry. So on to the participants.

For the moment let's go with encapsulating all method implementations in one class. We want to be able to have a method implementation selected because it is associated with a type. In internal polymorphism this association is drawn through the type that implements the method. Here it will be drawn by the type of the parameter in the signature of the method (i.e. internal = type.method(), external = method(type)).

public class ExternalVisitor

{

public void Accept(Animal animal) {}

public void Visit(Parrot animal){}

public void Visit(Alligator animal){}

}

I mentioned reflection earlier, that plus the concept of double dispatch can achieve external polymorphism. The Accept method on the class ExternalVisitor will use these concepts to dispatch to the method associated to the type of Animal pass it. It will reflect on the type passed as well as the methods named Visit searching for the method that accepts a parameter of the same or inherited type as passed. So if passed a Parrot the Visit method that accepts a parameter of type Parrot will be selected. The call will then be dispatched to that method (double dispatch). The call was redirected to the appropriate method, or double dispatched. If there is a type Cockatoo that inherits from Parrot it too would be dispatched to the method named Visit accepting a parameter of type Parrot.

I have packaged all the reflection stuff into a class called DoubleDispatchReflector. It is included in the ASOGS projects Patterns namespace. Here is some example usage.

public class ExternalVisitor

{

public void Accept(Animal animal)

{

DoubleDispatchReflector dispatch = new DoubleDispatchReflector(this, "Visit");

dispatch.Invoke(animal);

}

public void Visit(Parrot animal){}

public void Visit(Alligator animal){}

}

I don’t know about you but I think that provided a lot of bang for your buck. Two lines and we have the guts of external polymorphism working.

The participants explained so far implement all the methods to be dispatched to in one class. Lets change perspective and imagine that we have found someone else's ExternalVisitor and we would like to reuse some of it’s methods and create some of our own. We would like to aggregate some of our own new code and reuse some old code.

This scenario has been packaged up into a class named Prizm. It too is included in the ASOGS projects Patterns namespace. And again here is some example usage.

public class AggregateVisitor

{

public void Accept(Animal animal)

{

Prizm aggregate = new Prizm();

object[] ParameterLists = new object[1];

ParameterLists[1] = new Type[1] {typeof(Cockatoo)};

aggregate.AddHandler(new NewExternalVisitor(), "Visit", ParameterLists);

ParameterLists[1] = new Type[1] {typeof(Parrot)};

aggregate.AddHandler(new OldExternalVisitor(), "Visit", ParameterLists);

aggregate.Invoke(animal);

}

Well that seems to be more than enough for this post. Maybe next time I will write about using multiple parameters.

Note:

I have not yet released the aggregation class (Prizm) and there have been modification to the DoubleDispatchReflector since it's last release.

The examples shown here are not for production use. They have been made for easy reading.

All Sorts of Good Stuff

2005-06-20T15:06:00.000-05:00

I have not been able to find an appropriate project to push this stuff to so I have created my own, ASOGS. So far I have included these namespaces and classes:

ASOGS

Collections

Map
MapBase

ExceptionHandling

AggregateExceptionHandler
ExceptionHandlerBase

Reflection

AssemblyInformation
AssemblyInformationList
TypeArrayComparer
TypeArrayHashCodeProvider

Serialization

Cloner
Persistor
Serializer

Patterns

DoubleDispatchReflector
UniversalFactory

I have yet to move all the reuseable code that I have collected over the last year into the ASOGS project. Somethings that I plan to include are:

Exception Serialization Handling
Plugin Managment
Singleton Manager
Resource Pool Manager

I will try to post some details about these class in future blog entries, and get these additions into a ASOGS release soon.

Exception Handling Presentation

2005-06-17T09:52:00.000-05:00

I gave a presentation on OOP exception handling at Northrop Grumman yesterday. It covers the exception handling techniques that I have recently bogged about. The slides are all up to date, but the comments are a little sparse toward the end. After I digest the feedback from the presentation I will probably update the presentation. Enjoy.

An ExceptionHandler Example

2005-06-07T20:50:00.000-05:00

Here is a quick example of an ExceptionHandler and how to use it. First the dirived ExceptionHandler:



Class Example

    Public Shared Sub Main()
        Dim handler As New MyExceptionHandler
        Dim MyExample As New Example
        Try
            MyExample.UnsafeAction()
            MyExample.AnotherUnsafeAction()
        Catch ex As Exception
            If Not handler.HandleException(ex) Then
                Throw
            End If
        End Try
    End Sub

    Private Sub UnsafeAction()
        Throw New Exception("This is a test excaption")
    End Sub

    Private Sub AnotherUnsafeAction()
        Throw New IO.IOException("This is a test excaption")
    End Sub

End Class

Now using it:



Public Class MyExceptionHandler
    Inherits ExceptionHandlerBase

    Public Overloads Overrides Sub Handle(ByVal exception As System.Exception)
        Console.WriteLine(String.Format("Handling : {0}", exception))
    End Sub

    Public Overloads Sub Handle(ByVal exception As IO.IOException)
        Console.WriteLine(String.Format("Handling : {0}", exception))
    End Sub

    Protected Overrides ReadOnly Property UseDefaultHandler() As Boolean
        Get
            Return True
        End Get
    End Property

End Class

I you have played with the Exception Handling Application Block it may look similar. I thought that MS had beet me to the punch when I found that particular Application Block the other day. As far as I can tell so far they do not do any thing like the visitor pattern or polymorphism with the excpetion type. they use magic strings to determin which handler to give the exception to. Maybe next post I will does a comparison fo the two approachs. I have consitered contacting the mainters of that Application Block to discuss how the approach I have inovated could be used in the Exception Handling Application Block.

Aggregate ExceptionHandlers

2005-06-07T19:37:00.000-05:00

So I had a copy paste bug in my unit test for aggregate excpetion handling. It was using a table of signatures and handlers to determine which handler to dispatch to. The problem was

Hashtable(Signature)

does not do the same job as

Type.GetMethod("MethodName", Signature)

. The solution I found was Reflection.Emit. It was nice to have a real reason to learn some about this technology. I used emit to dynamicaly create a type with methods matchs all the signatures in the table.



Public Sub [AddHandler](ByVal handler As IExceptionHandler, ByVal ParameterLists As Object())
    For Each ParameterList As Type() In ParameterLists
        If Me.HandlerSignatures.Contains(ParameterList) Then
            Throw New ArgumentException("There is a handler that overlaps with the requested addition.")
        End If
    Next
    For Each ParameterList As Type() In ParameterLists
        Me.HandlerSignatures.Add(ParameterList, handler)
    Next
    If Me.IsActive Then
        Me.CreateAggregate()
    End If
End Sub

A client would pass what signatures from the handler should be added to the aggregate. The CreateAggregate method will use emit to create the aggregate. That code is a bit borring, thought what it does is cool. I learned a lot from Kenny Kerr's blog on IL. Just like layout of a UI Control a client can control creation of the aggregate. If many aggregates where being added SuspendAggregation couls be called and when the addtions where complete ResumeAggregation could be called to create the aggregate. When I was writting the HandleException methods of the AggregateExceptionHandler I noticed that the reflective double dispatch code I was writting was almost the same as ExceptionHandlerBase. I moved this code to a new class, DoubleDispatchReflector.



Public Class DoubleDispatchReflector
      ' Methods
      Public Sub New()
      Public Sub New(ByVal subject As Object, ByVal methodName As String)
      Public Function DispatchTo(ByVal args As Object()) As MethodInfo
      Public Function DispatchTo(ByVal arg As Object) As MethodInfo
      Public Function DispatchTo(ByVal subject As Object, ByVal methodName As String, ByVal args As Object()) As MethodInfo
      Public Function DispatchTo(ByVal subject As Object, ByVal methodName As String, ByVal arg As Object) As MethodInfo

      ' Properties
      Public Property MethodName As String
      Public Property Subject As Object

End Class

With that the AggregateExceptionHandler was complete. Now there are two standard ways to obtain reuse of ExceptionHandlers, inheritance and aggregation. Please download a copy and play with it. Let me know what you think.

True OOP Exception Handling

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

I have been having a problem with the use of try catch in .NET. It seems strange
to me that a series of catch statements would be used when all the power of OOP
is sitting there waiting to be used. I read an article about using Reflection in the Visitor Pattern for double dispatch. After reading this article I figured out
how to handle exception in an object oriented manner with in the try catch scheme. It all boils down to the following class:


Public MustInherit Class ExceptionHandlerBase

    Implements IExceptionHandler

    Protected MustOverride ReadOnly Property UseDefaultHandler() As Boolean

    Public Function HandleException(ByVal exception As Exception) As Boolean Implements IExceptionHandler.HandleException

        Dim handled As Boolean = False
        Dim types As Type() = New Type(0) {exception.GetType()}
        Dim MethodInformation As MethodInfo

        If Not exception.GetType Is GetType(Exception) Then
            MethodInformation = Me.GetType().GetMethod("Handle", types)
        End If

        If MethodInformation Is Nothing Then
            If Me.UseDefaultHandler Then
                Me.Handle(exception)
                handled = True
            End If
        Else
            MethodInformation.Invoke(Me, New Object(0) {exception})
            handled = True
        End If 
        Return handled
    End Function

    Public MustOverride Sub Handle(ByVal exception As Exception) Implements IExceptionHandler.Handle

End Class

I have only thought of a few qualities of this approach to exception handling that
make it a viable alternative or even an improvment on a catch blocks. First all
the power of OOP can be allied to architect exception handling. Second what
exceptions are handled is visible from the outside of a class. The following
are examples of an inheritor and a client.


Public Class ExampleExceptionHandler
    Inherits ExceptionHandlerBase

    Public Overloads Overrides Sub Handle(ByVal exception As System.Exception)

    End Sub

    Public Overloads Sub Handle(ByVal exception As IO.FileNotFoundException)
        'handle exception here
    End Sub

    Protected Overrides ReadOnly Property UseDefaultHandler() As Boolean
        Get
            Return False
        End Get
    End Property

End Class

Public Class Main

    Public Shared Sub Main()
        Try
            Throw New IO.FileNotFoundException("This is a test.")
        Catch ex As Exception
            Dim exceptionHandler As New ExampleExceptionHandler
            If Not exceptionHandler.HandleException(ex) Then
                Throw
            End If
        End Try
    End Sub

End Class

Clearly the only exception that Class Main will handle, because it uses
ExampleExceptionHandler, is FileNotFoundException. Normally one would have to
read the code of Class Main know what exceptions are handled. I have finished
an example for exception handling in the template Method Pattern, or Hollywood
Pattern. It basically consists of a mirror hierarchy of ExceptionHandler
classes, and a method factory implemented by the template Method concrete class
to provide the concrete ExceptionHandler. I have also created an
AggregateExceptionHandler which accepts multiple ExceptionHandlers. And I was
thinking of an ExceptionHandler base class that accepts multiple parameters, ie
ByVal exception as Exception, ByVal OtherObject as SomeOtherObject.

I had posted this entry a while ago but there was the possibility that my employer was
going to claim it as it's intellectual property.

There will be some more
posts on this subject shortly as the ideas did not seem patentable.

Serializer Plugin

2005-05-23T16:06:00.001-05:00

I have release my first plugin for Relector, Serializer. Below are some screen shots of the plugin in action. Select a class that is serializable, right click it and select the Serzializer menu item. The righthand panel will appear. You can edit the values of the properties and save it as a file, SOAP or Binary. If the property is typed as an abstract you can create a instance of a concrete type by right clicking the property name and selecting the type you wish to create. If you were wanting to open up a serialized object you can use the Open button or you can drag and drop the file onto the property grid. Don't for get to select what kind of formatter was used to serialize the object first. I plan to add things like user configured decorator streams, e.g. Zip Stream and Encryption Stream. Or even passing values to constructors. You can get Serializer or the SerializerPlugin from GotDotNet. You will need Jonathan de Halleux's Relector.Framework for this to work. Please get release 4.1.29.0 from ProjectDistributor. You will also need Relector.

The New Software Architect

2004-05-29T06:57:00.000-05:00

Have you ever heard of genetic algorithms? Codefarm is using genetic algorithms in their product Galapagos. They are marketing the software for engineering, finance, entertainment, biotechnology, and security. I have only ever seen this technology used to create circuits. It seems only a matter of time till this technology and software design patterns meet. The question is how fill they fit, how best will they work together.
If you know of Microsoft's WhiteHorse (I think this is it and this too) then you can imagine how one could use an interface similar to it to select an initial population. The more difficult part, as always, would be in creating the fitness tests for the evaluations of the newly spawned generations. Is your head spinning yet? If not you must not understand. This kind of technology has the potentially to change so much it is mind boggling. It is already starting to change the economy. How will you be effected?

WSS FAQ

2004-05-22T13:44:00.000-05:00

Home - WSS FAQ

This is just an all around good SharePoint Services site. Something I should hang on to.

Don Box's Spoutlet: Deconstructing Remoting

2004-05-22T09:05:00.000-05:00

Don Box's Spoutlet: April Don has an excellent spout on .NET Remoting, where it is going, and what to count on. His blog will not allow permalinks to old entries so I have copied it here. Deconstructing Remoting Grant Killian asks for the skinny on remoting. I've watched people try to give high-level guidance on this, but the fact that this has become a permathread means that a different approach is in order. It's actually quite simple if you're willing to take a few minutes to look at what's actually under System.Runtime.Remoting. The Good The transparent proxy/stack builder sink allow you to cons up an object reference for ANY CLR interface. That technology is alive and well and a crucial part of the CLR. When you make a channel call on a service contract in indigo M5 (our current milestone), the TP is working its magic on your stack frame. The CLR uses the TP/SBS infrastructure to allow object references to marshal across appdomains inside a process. That technology is also alive and well and frankly, it just works (if it didn't, the CLR would melt down pretty quickly). If you've ever called AppDomain.CreateDomain, you've been using the TP/SBS stuff. I would strongly recommend not counting on the existence of the CrossDomain channel. Its existence is undoc'ed and we've looked at various ways to change it's implementation radically to improve perf. The Bad We built support for WSDL under the TP/SBS infrastructure that is an architectural dead end. If you run into me at a conference, please do me a favor and let me remove SOAPSUDS.EXE from your laptop. The Ugly .NET Remoting really assumes shared classes and shared assemblies between the two endpoints. Indigo exists to break this dependency. This is the biggest architectural change but it's profound. V1 of the CLR shipped with an extensibility point for doing custom transport channels under the TP/SBS mechanism based on bytes. Indigo has a SOAP/Infoset-based architecture that we believe is more general and has a longer life span (yes, it's weird to think that SOAP will outlive bytes). V1 of the CLR shipped with a binary/TCP transport channel. There are no plans to support this one-off proprietary format natively in Indigo. For some ugly historical reasons, the TP/SBS infrastructure allows class-based remoting using System.MarshalByRefObject. Indigo does not require MBRO. Ending this permathread once and for all? The real asset is the TP/SBS infrastructure. If you find yourself wanting to use it, do so with a clear conscience. Feel free to point your management to this blog entry if that helps. If you're crossing host boundaries, ASMX is probably a better choice, both architecturally as well as in terms of tracking where the platform is headed in the next 2-10 years. 2004-04-26T03:14:52Z

A .NET Developer's Guide to Windows Security

2004-05-22T08:44:00.000-05:00

A .NET Developer's Guide to Windows Security

As Don Box spouts this book shows a "bottom up rather than the CAS-down approach". Always good to know more than one perspective.

TheArchitect.co.uk - Jorgen Thelin's weblog: Developing an Alerts Web Service

2004-05-19T19:32:00.000-05:00

TheArchitect.co.uk - Jorgen Thelin's weblog: Developing an Alerts Web Service

It would be nice to to do some thing like this to create an alert system for CruiseControl.NET.

Thoughtpost - Peer-to-Peer Development

2004-05-19T19:21:00.000-05:00

Thoughtpost - Peer-to-Peer Development

This company offers a free wrapper to the MS P2P SDK. It appears to be reputable, being that Harry Pierson, a member of the Microsoft Platform Strategy & Partner Group, is using it instead of rolling his own.

Some Good EAI Stuff

2004-05-18T20:38:00.000-05:00

A list of architectural Blogs.

Updated MSDN Architecture Site.

Recently MS created workspaces for community collaboration on architectural issues.

Book preview, Gregor Hohpe is one of the authors.

A recent ramble of Gregor’s.

Quantum Entanglment May Effect You Sooner Than You Think

2004-05-18T19:38:00.000-05:00

New Scientist

Apparently entangling a pair or more of photons lets you reduce their wavelength. This little trick can be applied to CDs to increase the density of data stored.

I wonder how long till entanglement can be used to teleport?

Get'n your news.

2004-05-15T10:15:00.000-05:00

MSN Newsbot

This is nice alternative to the Google news site.

Breaking the Static Friction of Commercializing Space

2004-05-15T09:40:00.000-05:00

It looks to me like the static friction is about to be broken if it has not already. Every week I see new articles about goings on in space by entities other than governments.

Space Tug and more »

X Prize

Space Port

Space Elevator and more »

It is all so very exciting; I am lucky to like the time I am living in.

I see said the blind man.

2004-05-12T15:55:00.000-05:00

I have my monitors set to 1280 x 1024. I can read most everything just fine on the flat panel, but on the laptop monitor things are just a little blurry. I saw a link on my MSN for ClearType. It is font display technology. I won’t go into the details, it just works. It made a significant difference for me. The following link will help you adjust your computer.

http://www.microsoft.com/typography/cleartype/tuner/1.htm

Strange Indeed

2004-05-12T11:20:00.000-05:00

I want one.

http://www.ambientdevices.com/cat/orb/orborder.html

Never in a million years

2004-05-11T17:21:00.000-05:00

I never expected to see such a credible source for a UFO sighting. Amazing

http://www.alertnet.org/thenews/newsdesk/N11505757.htm

X Prize 2005 Races

2004-05-11T15:23:00.000-05:00

Looks like New Mexico could be a hot place to live in the near future.

http://www.azcentral.com/news/articles/0511xprize-ON.html