Thank God Clay Tablets Never Took Off

While thinking about the use of paper as an interface metaphor the thought struck me what if paper had never been developed. What if we never moved beyond clay tablets and cuneiform. Can you imagine what the printers would be like?

Learning to touch type

After twenty plus years of of interacting with computers i have finally knuckled down and decided to learn to touch type.

It is one of those things that i have made half-hearted attempts at before but could never commit myself to. I always got too frustrated with trying to keep my fingers in one place for any length of time. Considering i got my first typewriter when i was sixteen it is not like i have in issue with keyboards or anything. Nor am i a member of the one finger school of typing. I am one of your head down bum up, whatever finger is available, kind of typist. All verve and passion but sweet F.A. in terms of accuracy and elegance. The other thing i started realising is that because i was still in essence have to pick keys out, deciding which one to strike with which finger, my brain was always having to think about two things at once. This is decidedly not efficient. As a tablet PC user this lack of efficiency was reinforced by the ease with ideas can be expressed when writing by hand.

So for the past month i have slowly been working on my touch typing skills. From somewhere i have found the patience to persevere and gradually my fingers are being tamed. Caps are still proving problematic, the little finger has always been the least disciplined of the bunch, and i have to tackle numbers, but it is getting there.

What i am finding interesting about the process is how, as with handwriting, one starts moving away from thinking about typing as the hitting of individual keys. Instead i am finding that words are being defined as set of finger movements. I think of a word and my fingers "know" the pattern to create that word. As a former musician i shouldn't be surprised by this but at the same time it is worth remembering and perceiving these processes at work. 

Deep Clone function for .Net 2.0

This is an update to some code I originally found in CodeBox for .Net. The purpose of the function is to fully clone a given object. The object passed does need to be serialisable. If it is not the function returns Null.

Imports System.IO
Imports System.Runtime.Serialization.Formatters.Binary

Public Shared Function DeepClone(Of T )(ByVal source As T) As T
     If Not source.GetType().IsSerializable Then
         Return Nothing
     End If

     Dim target As T = Nothing
     Using ms As New MemoryStream()
         Dim bf As New BinaryFormatter()
         bf.Serialize(ms, source)
         ms.Position = 0
         target = bf.Deserialize(ms)
     End Using
     Return target
 End Function

Generics in VB.Net and List.Find()

One of the things i have fallen in love with in .Net 2.0 is generics. With the current project i am working on i have been making extensive use of generics, not just for stronlgy typed collections but also for creating more methods. As with all things there is always something you run up against which can fustrate you more than it should. In this particular it was the Find() function of List.

The problem with the Find() function of List is it requires an instance of System.Predicate() as a parameter which in turn requires the address of the function which it represents.

Dim instance As New Predicate(Of T)(AddressOf HandlerMethod)

The HandlerMethod() would then contain the logic for determining which instance from the list to return. The BIG problem with this is that you can't pass any other parameters in to the method which means you have to either hardcode the search criteria into the function or if you are trying to match an existing object to one already in the List having to assign it to a global variable. In C# the solution to this is to use anonymous methods but that is not an option in VB.Net.

I spent a couple of hours wrestling with this and was about to resort to just looping through the list until i got a match when i found the following article:
http://blogs.sarkhouston.com/hdierking/archive/2006/03/26/3188.aspx

In this the writer provided a workaround so that an object could be passed in as a parameter. The solution is a little convaluted but it works. Anyway as i was looking at his could i saw an even simpler solution.

For this to work your class will need to implement the IEquatable(Of T) interface

public class MyClass
implements IEquatable(Of MyClass)
private _name as string
public Property Name() As String
Get
Return _name
End Get
Set(ByVal value As String)
_name = value
End Set
End Property

Public Function Equals1(ByVal other As Regulation_Type) As Boolean Implements System.IEquatable(Of Regulation_Type).Equals
return me._name = other._name
end function

Then in the code we can do the following:

dim myList as new List(of MyClass)
dim currentMyClass as MyClass

currentMyClass = New MyClass
currentMyClass.Name = "Bob"

if myList.contains(currentMyClass) then
currentMyClass = myList.Find(New System.Predicate(Of MyClass)(AddressOf currentMyClass.Equals1)
end if