Now, there are a few points I’d like to comment on - feedback as usual was varied, the overall average not too high… but that’s to be expected, especially with a topic like that in the context of the day.

To the 21 people who left an 8 or 9 rating - thanks! There’s not much to say about this since comments were very positive.

The comments on the 7s are a bit more interesting - some of them are still positive, some others are more critical. In order of appearance in the list.

> Second time in a row Oliver has overrun and not covered everything on his agenda, the same happened last year with his WPF session. He needs to work on his timings.

Hm… well, I don’t agree. Perhaps I should post about this in general, because apparently my point of view in this regard isn’t well understood - I get comments about this all the time. In a nutshell, my sessions typically include content that most likely I’m not going to have time to present. The reason it’s in there (in the form of slides and/or samples) is because I found it interesting during the research phase of session preparation and I’m thinking it might be interesting to the people who download my slides and samples after the presentation. It might also come in handy when I deliver the presentation again, with a slightly different target time (this varies a lot from event to event - everything between 55 and 90 minutes for a session slot is quite common). If I remember, I try to explain this in most sessions - I don’t remember whether I did this time or not.

Of course there are also considerations specific to the event in question. For starters, Dave insisted when he talked to me that I submit something entirely new, not something that was previously done elsewhere. Looking at the presentations I saw on the day, I have my doubts whether everybody adhered to that rule, but I did - as a result, this was a first run for the presentation, and these will always be a bit less perfect on timing than subsequent runs, no matter how well prepared somebody is.

Finally, of course, I didn’t run over - I simply adjusted the session content to fit the time frame and left out a few minor bits at the end because time didn’t allow for them. If you don’t like it, my apologies - these bits and bobs are out there in the wide world whether you like it or not. As it is, they are included in the slide deck, and it seems you’re saying I should have left them out. Go figure.

> I think the session would have benefited from getting onto the code samples sooner.
> Whetted our apetites, but didn’t make time to cover the more exciting parts.
> Super fast, but I enjoyed having an introduction to this.
> I thought drilled too quickly into the code examples.

Yeah well… what are you going to do in 60 minutes, when 90% of the audience are on the "F-what?" level to begin with? And as you can see, this is a subject that splits any audience…

> There was no sense of where this language’s niche was.

Fair enough - I can’t tell you though. Still waiting on the MS niche definition committee to finish its work. In the meantime, just listen, get up to speed if it sounds interesting, and make up your own mind.

> In places I felt that the presentation and samples could have been tightened up a bit. Removing a bit of waffle.

Interesting to hear that - I don’t think the majority would agree that there could have been much more in it though.

> Oliver picked an interesting subject, but could really have benefitted from giving a concrete reason for using this language - the benefits of functional languages over imperative perhaps? As it was: interesting but ultimately not useful for everyday coding

I was leaving that part open to your own imagination at this point. I think I did mention areas in which people are currently using F#, and of course general internet content about functional programming will bring up a lot of ideas. Anyway, I think you got the right impression - for the majority of developers, F# is probably not an everyday programming language today, and who knows if it will ever be.

> … I was left wondering why I would choose to use it for data access over c#

I wasn’t saying you would. Some of the techniques I showed were from the functional part of the programming world, but that doesn’t mean you can only use them in F# either. In general the session was supposed to be an introduction to the language and some of the more obscure (from the typical .NET programmer’s point of view) practices, as well as to point out that F# is a .NET language after all and a lot of the standard technology can be used just as easily as it can from C#.

> Interesting stuff… though more of an introduction to F# than handling data!

Yes, that’s what it turned out to be. Or at least it was half and half, I guess… the NxtGenUG guys always ask for bleeding edge technology and their event focus was where the data handling part came from. On second thought, it turned out that the necessary basics took up a bit too much room in this presentation. Will have to ask for a double slot next time, to do a separate introduction and the data handling thing in its whole glory

> I liked the happy go lucky presentation style

Eh?

> … it was too left field for a mainstream session ….

I agree. It wasn’t supposed to be a mainstream session. The way I’ve always understood it, the NxtGenUG Fest isn’t supposed to be a mainstream event.

> personally I dont and neither did anyone around me have any real interest in F#

Out of the other 52 who left feedback, around 48 did though.

> Really not sure

I think the answer is 42.

Now, while I’ve found it useful on the Mac to have the Command key easily accessible (although Ctrl is still used in too many places, like terminals and things… gotta find a solution to that), that key is recognized as a Windows key in VMWare. So I changed one of the registry trickery files so that the Windows keys get remapped to Ctrl for use in Windows. Works like a charm. Here’s what the content of that .reg file looks like:

Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]
"Scancode Map"=hex:00,00,00,00,00,00,00,00,02,00,00,00,1d,00,5B,E0,1d,00,5C,E0,00,00,00,00

Hope it helps somebody!

I’ll certainly post more about this in the future. I’m not planning on abandoning Windows, or .NET, or anything like that - on the contrary, I want to see what other platforms have to offer these days, be it for competition or compatibility. Mono is supposed to be able to run most Windows Forms apps these days, I hear… now I only need some time

If you haven’t had a look at the Mac since they started building Intel based machines, go do so as soon as you can. You are really missing out.

Later this week I’ll be in Reading for the NxtGenUG FEST 08 event on June 12th. Hate to state the obvious, but it’s the 2008 incarnation of their yearly FEST event. A day of great speakers and sessions, the usual (well, usual for NxtGenUG standards — if your’e not familiar with it, be prepared to be amazed) assortment of swag, pizza and so on… It costs a bit of money for non-members of NxtGenUG, but it’s still quite a bargain at 49.99, and of course it’s free for members. Sign up is here, and there’s a G(r)eek dinner the night before. Originally it was planned to send Daniel Moth off to the states, but now I hear he can’t make it to the dinner… anyway, if you happen to be in Reading on the night of the 11th, sign up here and join us for the geek dinner!

Right, that’s it — I have some sessions to prepare…

Today I thought I’d look into something that I’ve never looked into before: see whether it makes sense to upgrade a flight with those miles. I’d tried before to use the online function to do that, but every time I’d been told there was some sort of problem and I should contact my "booking agent". Flight booked online, sometimes even through BA directly, so wtf is that about the booking agent? Why no proper information about what the problem is? Hm…

So I took the time to call them and spend 20 minutes in a phone queue. Of course it was the wrong phone queue - even though I’d taken the number from that online error page, there’s a different, Executive Club specific number I should be using. Okay, got transferred. Other girl, same problem, transferring me elsewhere again. Finally somebody who knows what to do, he looks at my booking and goes "well, that’s not the right kind of ticket". What? Kind of ticket? "Yes, you should have a ‘flexible’ ticket so you can change it later. When booking online, there’s a choice between a cheap and a flexible ticket." Ah, how stupid of me.

I ask the guy if I could theoretically get anything useful for my 30000 miles on my flight to Orlando and it turns out that 25000 miles will buy me an upgrade to World Traveller Plus. Wow! Hallelujah! Just 18 months of careful airline selection and already can I afford 10 additional centimetres of leg room! So he goes, "I’m going to call our sales guys and ask them what the upgrade to a flexible ticket would cost for the trip." Comes back, and it turns out that upgrade costs about 420 quid. I say hey, that’s a bit expensive, isn’t it and he replies "no, and that’s just for one leg of the trip because <weird stuff here> - you can’t get the upgrade on the way back, but for the one leg it’s just 12500 miles".

Phew. That’s it, is it? Pay around 3 times the price for the London-Orlando leg of the trip to get a flexible ticket, and then 12500 miles to upgrade to the next, almost identical, class of travel. Frickin’ unbelievable.

Now, people tell me there’s more to frequent flyer programs - for instance, when you fly enough within one year, you get into a higher class and then you get all sorts of benefits like 150% miles on the mile (What’s the idea with "miles" anyway? The miles I get credited don’t have any similarity to the distance between the start and end of my flight.) and free upgrades to higher classes. Well, BA do 125% and 150% miles, yes. Other benefits available here (or probably not, because you have to be a privileged person with your own login in order to see this). But as far as I can tell they never give me any free upgrades, whatever I do. And most importantly, to be a better Executive Club member than I am today, I need to collect Tier Points. Now wtf are Tier Points suddenly? Check my account - I have ZERO of them. I need another 600 and 4 qualifying flights to get to Silver membership. Hm…

Looking around, I see where to get Tier Points from. Obviously I don’t get them from the kinds of flights I always use, otherwise I’d have some. But there’s a wild list stating that depending on the class and area I fly in there are 20 different fare classes (yes, really!) and all of them collect Tier Points (no further details). For some reason apparently I manage to travel outside these classes all the time - no info on that either.

Now how to figure out what fare class a ticket is in? Oh, easy: look at your boarding card. Yes, that card you get at the airport to carry around for an hour. And yes, the info is on that part of the card that gets ripped off and taken away from you when you board your plane. If you have some form of printed ticket that nobody uses anymore these days, it might also be on there. E-Tickets? Nah, not on there. Well, go figure.

Eat shit, Executive Club.

Basically, the compiler seems to read each source code file from top to bottom. Generally, things that are defined below the current line can’t be referred to in the current line. Apart from the order of lines in source code files, the order of source code files in the project is equally important, since the compiler handles them in precisely that order. 

Hint for Visual Studio users: While the order of source code files in the project is represented correctly in the Visual Studio Solution Explorer, it can’t be changed from there. Instead, it is necessary to edit the project file and swap source code files around manually. Right-click the project in Visual Studio and select "Unload Project" from the context menu. Right-click the project again and select "Edit <projectname>.fsharpp". When you’re done making your changes, use the context menu a third time to select "Reload Project". You will see that the order of files in Solution Explorer has changed according to the changes you made in the project file.

In some schools of though on programming, this linear view of things might seem quite normal, but in .NET it is not. In main-stream .NET programming, it was widely regarded a great innovation when C# took care of the old problems that C and C++ had in that regard (no more header files!!!). Pascal wasn’t any better, and many other languages - most of them had some sort of "pre-declaration" feature that had to be used when, for instance, a reference to a certain type needed to be created before the type itself was declared. Nothing like that in C# — the compiler looks at all the types and namespaces declared somewhere in my current project and figures things out for me. Great, that’s how it should be.

In all fairness, in F# there’s at least one very obvious reason why the compiler takes that linear approach: type augmentations. They basically mean that depending on the position in code, a class might have a certain member or not. If you’re not familiar with the feature, look at this example:

type MyClass() =
    let answer = 42
	
let mc1 = new MyClass()
	
// At this point Output can't be found on mc1
//mc1.Output()
	
let output x = printfn "%d" x
	
type MyClass with
    member x.Output() = output 52
	
let mc2 = new MyClass()
mc2.Output()
	
// Now Output is part of MyClass, so I can even call
// it on my "old" instance
mc1.Output()

The particular case I’m dealing with is that of persistent business class hierarchies. These hierarchies are typically interrelated to the point where one or more networks of classes are formed. As an example, consider modelling a hospital. You’d have a whole bunch of different types of people to store, so you’d have classes for People and Addresses, Employees, which might be Nurses, Doctors and cleaning and housekeeping personnel, Patients with relationships to the Nurses and Doctors, Rooms, Floors and OperatingTheatres which are assigned to Doctors or Teams of Doctors. Visitors, CarParks, the whole Accounting and Booking business… the list is endless. It is quite clear that many of these types have references to many other types, and typically a one-to-many relationship is modelled with a collection property on one end and a simple reference on the other end, so as soon as there’s a relationship there, it will result in two classes interrelating.

Sure, not all classes interrelate, so it might be possible, taking a lot of time and great care, to separate the classes into groups that are hopelessly tangled, but have only unidirectional references outside the group. Of course it might make sense in the example above for almost all classes to have a reference to the Hospital type, since that is important if there’s ever more than one hospital being handled at once. There might be other such "special", high-level objects that make the grouping approach really complicated. In any case the task of sorting the classes into such groups is extremely tedious and the grouping breaks easily, as soon as any class is changed to include or exclude a property that refers to another class. You might wonder why I’m going on about the grouping thing at all — well, read on, that’s what F# wants me to do.

Have I mentioned that persistent business class hierarchies can be large? Apart from having private fields and public members for each and every piece of data that is associated with the various entities, the classes will typically also contain certain parts of business logic functionality. Depending on the architectural approach that is used, validation logic might live in these classes, as well as a lot of the state handling that many entities need. To mention some numbers, a C# project I’ve worked on myself — really just a medium size application — has 75 persistent classes and a total of 11263 lines of code in these classes.

type ClassA() =
    let foo = new ClassB()
	
and
 ClassB() =
    let foo = new ClassA()

As you can see, this uses the "and" keyword to concatenate the two type declarations. This doesn’t hold true for classes only, but for all types. One of my first thoughts about this was that it shouldn’t be that much of a problem if my application made use of lots of interfaces and dependency injection throughout to remove the need for direct references from one class to another. But in the end this approach only shifts the problem to the interfaces - at a rough count, that class hierarchy from my old project would require me to declare 75 interfaces with 520 properties and around 300 other members. For those declarations, the problem is still the same, and while the volume may be smaller, it’s still significant. Plus, of course, it requires my application architecture to work in a very specific way, I need to create all those interfaces for no real reason whatsoever, … doesn’t sound like a very good idea.

In the end I don’t think that this problem is entirely particular to my use case. In other class hierarchies, dependencies might typically be somewhat more linear than they are in those hierarchies I’ve described, but interrelations are still rather common. So here are the important points I want to make:

The general assumption in F# is that null values are a threat and so the languages discourages their use. I totally see the point and if all I wanted to do was create classes (or perhaps not even those) for use in F# itself, I wouldn’t have a problem with it - but interop is an important thing for F#, as I see it, and all the rest of the .NET world makes elaborate use of null values. Null values are the (rather more dangerous) alternative to F# Options to most .NET developers - exactly the same purpose, just a less elegant implementation.

I haven’t given up on the Hub yet, although I have to say I haven’t received any useful replies from there yet… and the people who do reply are rather those that like to write forum posts than those who really know what they’re talking about Anyway, perhaps I’ll get lucky with a blog post again - Brian, are you still reading?

UPDATE: I found the solution to this problem in the release notes for F# 1.9.4: use the Unchecked.defaultof<T> function. I guess that’s the new functionality that was referred to earlier. Great!

FATAL: Module ip6_tables not found.
ip6tables v1.3.8: can't initialize ip6tables table `filter': iptables who? (do you need to insmod?)
Perhaps ip6tables or your kernel needs to be upgraded.

Well, I don’t have ip6_tables compiled, which is just the reason I liked that flag when I saw it. Read the source, and I found that the flag doesn’t mean "don’t use IPV6", but rather it means "use ip6tables to take some special action to disable IPV6". Well.

I searched for the piece of documentation I was missing (because I wasn’t assuming there’d be anything to misinterpret about the meaning of that flag), but I still can’t find anything… apart from this forum post where somebody states "… this is because in a perversely twisted form of logic the configuration file requires you to have IPV6 support to be able to disable it …" Well put.

#light
open DevExpress.Xpo
type Person = class
  inherit XPObject as base
  public new(session : Session) = { inherit XPObject(session);
    name = string.Empty
  }
	
  val mutable private name : string
	
  member public x.Name
    with get() = x.name
    and set(v) = x.name <- v
end
	
let person = new Person(XpoDefault.Session)
person.Name <- "Wally"
person.Save()

This works just fine - great. Now I wanted to create a slightly more evolved sample using more of the standard XPO features, and use that to develop some best practices. I also had the idea to create some CodeRush templates similar to those we have for C# and VB.

All this turned out much more complicated than I thought, for a variety of different reasons. The first issue I stumbled upon was that I can’t call our standard helper method SetPropertyValue correctly from F#. It looks like a bug to me, since I did a lot of very similar tests, and only with the precise combination of parameters and return type that this method has does the F# call to it fail. If it’s confirmed to be a bug, it’ll get fixed - but so far I haven’t heard anything, and I want a workable solution now.

I started working on one - see below -, but first I had to decide which type of mutable fields I was going to use for my persistent classes. F# allows class fields to be declared "mutable", which means they can be changed (if this sounds like an ordinary thing to you, I recommend you read up on your functional programming theory <g>). It also allows to declare values as "ref cells", which wraps the actual values in an additional class internally.

Our standard SetPropertyValue method uses a "ref" parameter in its C# implementation. Of course that method isn’t working anyway, so I was considering writing my own helper method for the time being. C# ref parameters are not something F# deals with extremely gracefully in my opinion, the main reasons for which are probably that changeable values are not foremost in peoples’ minds in that language, and there’s support for multiple return values using tuples, so the use cases from ref parameters are much reduced anyway. The only way (afaik - a topic I’m still a little unsure about) that F# ever passes a parameter by reference is if the value I’m using is a ref cell in F#.

The problem with using multiple return values instead of the by-reference type method, whether we’re talking about the standard helper method or a new one, is that it changes the requirements of the syntax at the call site. Optimally, I would like the helper API to be very easy to use. I also want to perform change notification from within the helper method. Using multiple return values, the pattern could look like this:

let setValue oldVal newVal =
    ((oldVal <> newVal), newVal)
let testSetValue1 newVal =
    let mutable testval = 10
    // This is the line I'd need in my property setters
    match (setValue testval newVal) with | true, __n -> testval <- __n | _ -> ()
	
    printfn "testval: %d" testval
	
testSetValue1 10
testSetValue1 42

There are several things wrong with this. First, the line I need to use in each property setter is rather complicated. I’d integrate it in a template, but there are people who don’t use templates, and anyway it just looks wrong to reproduce that sort of thing in every single property. Second, the naming of the helper function is really no longer correct - it doesn’t actually set the value of the property anymore, it just finds out whether setting the value is required at all. Of course if that’s all I want to do, I should change the function’s name and I don’t need multiple return values after all… the real problem is that the actual setting of the value happens in the property setter code. And that brings me to third: if I was to integrate change notification in the helper function, this would now happen before the property change actually takes place (and that’s still assuming that it takes place at all, which is not under the control of the helper function anymore).

So all this looked bad to me and I decided to go with the by-reference type helper function after all. This works only if the value I’m actually setting from inside the helper function is a ref cell. In C#, it’s possible to take any given variable and pass a reference to it into a method that requires such a reference. Not so in F#, apparently. Unless a value is declared to be a ref cell, it can’t be used in this way. Declaring as a ref cell in turn means that there’s an extra wrapper class created for the value - quite a bit of unnecessary overhead it seems, particularly when dealing with large numbers of fields such as there are typically in persistent classes. But since ref cells are the only way to make the F# compiler pass something by reference, there’s no way around that. I did some additional tests with temporary ref cells and other things, but this only made the overhead worse, not better. So I decided to accept things as they are and move on.

One other thing I should mention about ref cells: they require special syntax when used in code, basically they need to be dereferenced in order to access the actual value. So instead of writing "foo" to access the value foo, I now have to write "!foo" (yeah, looks like "not foo", but it’s not, if you know what I mean <g>). Quite inconvenient as well, if you write a lot of business logic in your class and prefer to use the private field directly. Probably better to use the public properties where possible, then you don’t have that problem.

My next step was to try and pull the helper functions which can’t be called in their original C# implementation into F# as a workaround. That looked pretty simple to begin with - our C# implementation is actually quite a bit more complex because we have to jump through some hoops to get the equality comparison right (that’s the reason for having the conflicting overloads I mentioned earlier). I created a base class that I was going to use for further objects:

type FSharpBaseClass =
    inherit XPObject as base
    public new(session: Session) = { inherit XPObject(session) }
    member public x.SetPropertyValueFS propertyName oldVal newVal =
        let needsSetting = !oldVal <> newVal
        if needsSetting then
             oldVal := newVal
        x.OnChanged(propertyName, !oldVal, newVal)
        needsSetting

And lo and behold, here’s the next inexplicable F# issue: I can’t call the OnChanged method! Again, no idea why that is - I did a bunch of tests with very similar setups and all of these work. OnChanged can’t be called though, I get a compiler error: Error 5 A protected member is called or a base variable is being used. This is currently only allowed in the direct implementation of members since they could escape their object scope.

Of course there’s not a single page that Google can find about this problem, that would have been boring. Ah well. That’s it for today in any case. To be continued.

<Style TargetType="{x:Type Button}">
  <Setter Property="Background" Value="Red"/>
  <Style.Triggers>
    <Trigger Property="IsMouseOver" Value="True">
      <Setter Property="Background" Value="Green"/>
    </Trigger>
    <Trigger Property="IsPressed" Value="True">
      <Setter Property="FontWeight" Value="Bold"/>
      <Setter Property="Width" Value="200" />
      <Setter Property="Background" Value="Lime" />
    </Trigger>
  </Style.Triggers>
</Style>

With a few buttons on a form and this style code installed in App.xaml, you can easily see that he’s right - the IsMouseOver property change triggers a change of the background color to green, but IsPressed seems to do its job only partly, since it misses setting the Background property to Lime. In the original example, the change to the background color in that trigger was actually the only thing that was supposed to happen, so it looked like nothing was happening at all. With my changes, it seems obvious that the trigger is observed correctly, but the Background property change doesn’t seem to be executed.

The reason for this behavior is simple: there are standard templates in place that format the buttons in the way we’re normally used to seeing a button formatted. On Vista that means setting the background color to a certain gradient, displaying a rounded rectangle, and having certain animations in place that are executed when the button is focused, the mouse moves over it or it is clicked. This standard behavior is also implemented as control templates using triggers, and so interests collide - the triggers in the sample code actually do set the background color to Green or Lime, only the standard trigger quickly starts doing something else. As a result, the IsMouseOver trigger sets the color to Green only for a short while before the standard animation sets in, and in the IsPressed case the color is actually never seen.

To solve this problem I used Blend to get hold of the standard control template for a button. I opened my test solution in Blend, selected one of my buttons and used the context menu entry Edit Control Parts (Template) | Edit a Copy… to have a block of code for the base template inserted into my XAML file. Note that this block is inserted into the Window class XAML file by default. In many cases this is actually the sensible solution, but in the sample application I had my styles defined in App.xaml, so I had to move the block across to that file. If you do this, be aware that there’s also an XML namespace Microsoft_Windows_Themes inserted by Blend, which you have to move together with the code in order to make things work.

Now, if you have a close look at this code that has been created by Blend, you will see that there are three "events" called RenderDefaulted, RenderMouseOver and RenderPressed configured to call various elements of the ButtonBase class, which are pulled in using the TemplateBinding syntax extension. In addition, there are some triggers that are also involved with changing the button’s appearance in response to various events.

For this example, I chose to remove all those elements to break things down to an extremely basic button that doesn’t react visually anymore (apart from my own triggers) to mouse moves or clicks. In reality this might not always be the right thing to do - this article is just meant as a starting point for readers to figure out what they need to do in their own use cases. Anyway, after my modifications, this is what I was left with:

<ControlTemplate x:Key="buttonTemplate" TargetType="{x:Type ButtonBase}">
  <Microsoft_Windows_Themes:ButtonChrome x:Name="Chrome"
     SnapsToDevicePixels="True"
     Background="{TemplateBinding Background}"
     BorderBrush="{TemplateBinding BorderBrush}">
    <ContentPresenter
       HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
       Margin="{TemplateBinding Padding}"
       VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
       SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"
       Content="{TemplateBinding Content}"
       ContentTemplate="{TemplateBinding ContentTemplate}"
       RecognizesAccessKey="True"/>
  </Microsoft_Windows_Themes:ButtonChrome>
</ControlTemplate>

Blend had automatically inserted a Template attribute for this control template into XAML, to make the particular button, which I had called the context menu on, work with this template. So I just had to run the application and there it was - two buttons still working in the same way as ever, and a third one without any of the animations and perfect green and lime colors depending on mouse state. Great!

You can download the source code for my test application here: WPFControlTemplating.zip (9016 bytes)

VBUG did their Spring 2008 Conference last week. In the beginning, Andy was tired , Chris was enthusiastic and Tim was … … also there. Dave was hungry and then he couldn’t get in . When he finally made it, he was the only one in Rich’s session and had to be revived . Not quite Dave’s event - he was scared of his computer and ended up starting his own presentation early .

Mark , Gary and Rich sang , and everybody danced

In the end it was all as it should be.

Great event, guys!

The categories we entered were Best Add-in, Best Charting and Graphics Tool, Best Component Set, Best Grid, Best Navigation Suite, Best Online Editor, Best Printing/Reporting Tool and Best Scheduling/Calendar Tool. Our overall package DXperience was also named Product of the Year.

Look here for more info, the official thank-you to everybody and a few words from Julian.

Anyway, I was trying out some things with UAC, looking at the way different elevation prompts are displayed depending on whether or not the current user is an Administrators member or not, and so on. Previously I was working in what appears to be the default configuration, which my user account being a member of the local Administrators group and the Administrator account disabled and without password.

I activated the Administrator account and gave it a password. Then I removed my own account from the Administrators group and added Power Users instead. I played around with this setup and then decided to go back where I came from - only I made a mistake, I disabled the Administrator account first, before assigning the Administrators group back to my own account.

As a result, I can’t currently find a way to get Administrator privileges on my system! I can’t log in as Administrator because the account is disabled. For the same reason I can’t use the "runas" command to run any admin tools. And elevation offers only my own account (pretty weird that - why does it offer to elevate into my own account if I’m not an Administrators member at all?), which allows me, after entering my password, to bring up Computer Management - but I still can’t make changes to any account settings, obviously.

What do I do? I can see that I wasn’t thinking enough before making those changes, but I’m still having a hard time believing that I managed to lock myself out completely, i.e. the only solution is a restore from backup. Any ideas, please?

Update: I found a solution on this very helpful page: http://www.jimmah.com/vista/Administration/locked_out_of_admin.aspx I feel quite lucky that the no. 1 option actually worked for me and I didn’t have to use any of the other two - but at least there seems to be hope even if the situation is worse than mine turned out to be. In case you need that article and the above link should have stopped working, I have a local copy of it that I might be prepared to pass on in that event. Thanks to everybody who helped!

Some extensions come in both 32 bit and 64 bit versions, and it should be possible to install them both. I’ve seen some extensions do this automatically and then it works fine - but some other vendors distribute both versions of their products with exactly the same file naming, so you can only install either one of them.

The whole thing seems a bit stupid to me… I wonder if it wouldn’t be possible to create a 64 bit shell extension that includes the 32 bit extensions in the 64 shell. Yes, I know I can’t load the extensions directly, but I could run a separate 32 bit executable that loads them and passes over all relevant information to the 64 extension - and the other way round of course. This could work both ways actually, also enabling 64 bit extensions to be available in 32 bit hosts. Of course that’s quite a bit of information that has to be transferred very carefully, mapped correctly and so on… just the sort the thing that Microsoft could have done in Windows, probably not the sort of thing I’m going to take on myself over the next weekend.

Now, for most applications I’ve been able to use Explorer for 64 bit extensions and Altap Salamander, which I use anyway, for the 32 bit ones. But I encountered a worse kind of problem the other day, when I was trying to Anapod (brilliant iPod tool, btw - can’t begin to describe how much better than iTunes it is). Anapod comes only in a 32 bit version so far. It installed just fine and then it ran the tray application and connected to my iPod. Great. Problem was, the context menu entry I normally used to bring up Anapod Explorer and access the contents of my iPod wasn’t working - some weird error message.

After a little while, I figured out what was going on. Normally, Anapod installs a top level shell extension, which displays an icon for the iPod in the main "Computer" window in Explorer. Said context menu entry simply goes and brings up an Explorer window in the right location. Because the extension that was installed was 32 bit, my 64 bit Explorer couldn’t open a window in that location. Hm. Of course there was also no other way to get to that location from the 64 bit Explorer.

I thought for a bit and then remembered that there’s a 32 bit version of Explorer also installed on the system. By default the path to it is C:\Windows\SysWOW64\explorer.exe. I tried running it, but I still couldn’t access the Anapod shell extension. After a while I found that Task Manager listed the second running Explorer instance as 64 bit - why? I don’t really know. The funny thing is that if you watch Task Manager closely while running that version of Explorer, you’ll see that for a very short time it actually shows the "*32* marker, but then this goes away and it’s 64 bit again. I don’t have an idea why that happens - I’ve only been using 64 bit Windows for a few weeks and I don’t know anything at all about its execution model.

The solution I finally found (my apologies - I don’t remember where I found it and I didn’t store a bookmark) involves a way to run a 32 bit Explorer instance on 64 bit Windows, but it’s certainly not intuitive. To make it work, you need to create a shortcut to Explorer (I’m actually still using the SysWOW64 one, but I believe the standard one should work equally well) somewhere and then change it’s properties. Set the Target of the shortcut to this: C:\Windows\SysWOW64\explorer.exe /separate, ::{20D04FE0-3AEA-1069-A2D8-08002B30309D}. Great, isn’t it? Again, I don’t really understand this at all, just passing it on

This solution works just fine with Anapod. I still can’t use the context menu entry to bring up the Explorer window, but with the tray tool running and the iPod connected, I just open a 32 bit instance of Explorer and browse into the iPod from there.

Set-ExecutionPolicy RemoteSigned

I ran PowerShell as a normal user (through SlickRun - brought up the 32 bit PowerShell without me noticing at first), tried to run a script and it failed. Get-ExecutionPolicy still showed Restricted. Wtf?

Turns out that the execution policies for 32 and 64 bit PowerShells are stored separately. I don’t know, I can’t figure out any value in this apart from the obvious "let’s fuck with their minds" conspiracy idea. Probably something that wasn’t really done on purpose, but still pretty important to know.

For example, Explorer shows me SnippingTool.exe in c:\windows\system32 (system32? Go figure), while my 32 bit Altap Salamander doesn’t show the same file in that location. In SlickRun it was equally impossible to configure my command to use that path, and when I tried to use the path to the start menu .lnk file instead, SlickRun’s path completion feature actually showed the .lnk file, but running it was still impossible.

After a little search, I found this forum post here, which describes an option for 64 bit systems. Quoting (I don’t trust forum content to be there when I go back later):

Try this:

• Close SlickRun
• Open C:\users\yourname\appdata\roaming\slickrun
• Edit SlickRun.ini
• In the [General] section, add the line:

                Wow64Hack=1

I activated this hack and things are better now - the PowerShell command runs the 64 bit version, and the SnippetTool can be run from it’s (alleged) c:\windows\system32 location. I still can’t use the .lnk file though, since I get a number (five or so) error message about Crypt32.dll when I try.

If you haven’t considered coming to any of these events, now is the time to do so - there’s lots of stuff going on, and since all of these events happen "off the beaten track", we hope to see some people there who couldn’t easily make it to the more "standard" event locations in Reading or Dublin.

Here’s where I’m going to be:

VBUG Spring Conference, Birmingham, UK - April 24th

DDD Ireland, Galway - May 3rd

DDD Scotland, Glasgow - May 10th

I believe I’m also going to be at the North East Scotland .NET User Group on May 14th, but they don’t have an announcement for the event yet. Hope to confirm that later.

As usual, I hope to find the time one day to do a bit more blogging than I’ve done in the last year or so. At least I am finding time to do a lot of speaking at user groups and events. If I haven’t been at your group and you would like me to, feel free to contact me!

Last year this one-day event was great, I’m sure it’s going to be another day full of fantastic content this year. “Data today, data tomorrow” is the motto this time - a great idea, I think, since almost everybody works with data in some shape or form these days. So, I hope to see you there!

In Galway, I’ll do a WPF session for GMIT students on Monday afternoon, and “Functional Programming in C# 3.0″ in the evening at GAMTUG. If you want to be there, follow this link for all the details!

On Tuesday I’m going to be in Cork, delivering a WPF session again. Here’s the link for that one - hope to see you there as well! The video is actually about my WPF introduction, but if there’s enough time, I might well do the longer “WPF in business applications” talk instead. We’ll see.

Wednesday I move on to Dublin, where I’m going to meet up with a lot of other people for the fantastic IMTC conference. They still have room and the speakers list is impressive, so if you can make it to Dublin for April 2-4, or even for one of the days (sessions are 3rd and 4th), I’d recommend this! My sessions are on Thursday, I’ll be doing an introduction to LINQ as well as Functional Programming in C# 3.0.

During all my sessions I’ll be giving away complimentary Developer Express licenses! (Well, I’ll talk to the organizers to prevent p****ing them off, but I would like to do that at every session.)

In the URL for the application, I tried replacing “localhost” with “127.0.0.1″ and I found that this solved the problem. I ping’d localhost and I noticed that it was using ::1 as the address instead of 127.0.0.1 - the IPv6 equivalent. I looked in my hosts file and there was an entry in there, combining ::1 with localhost. Removing that entry solved the problem.

Now, this is a bit weird… I actually thought I didn’t even IPv6 enabled at all, which would have explained why connections to ::1 wouldn’t work. But I found that it was in fact active - not sure why, I believe I switched it off at some point. Pinging ::1 is not a problem. So why can’t IE connect to it? And who added the ::1 entry to my hosts file recently? Or was it previously working in spite of that entry?

Bizarre Windows network stuff… see, that’s why I still love Linux for my servers. Text based config files that never suddenly change automatically. Great.

Number 1 - implementing interfaces that include events is a PITA

I was trying to implement INotifyPropertyChanged, which contains the event PropertyChanged. Eventually I found a working description in this forum thread. I’ve now implemented the interface and a helper method to fire the event like this:

  interface INotifyPropertyChanged with
    member x.add_PropertyChanged(handler: PropertyChangedEventHandler) =
      x.notifyPropertyChangedHandlers <- (Delegate.Combine(x.notifyPropertyChangedHandlers, handler)  > PropertyChangedEventHandler)
    member x.remove_PropertyChanged(handler: PropertyChangedEventHandler) =
      x.notifyPropertyChangedHandlers <- (Delegate.Remove(x.notifyPropertyChangedHandlers, handler)  > PropertyChangedEventHandler)
	
  member private x.PropertyChanged(propertyName) =
    x.notifyPropertyChangedHandlers.Invoke(x, new PropertyChangedEventArgs(propertyName))

Hm… my stupid blogging system apparently likes those smileys that crept into the code sample above. That’s the downcast operator being used where the smileys appear… colon, questionmark, greater than. Sorry about that.

No idea whether this is the best way - at this point I found for the first time that documentation is currently badly lacking… no mention of anything like this in any official place I could find, nor in Don Syme’s or Robert Pickering’s books (the latter wrote the forum reply at least <g>). Was this forgotten? What’s worse than having no docs is that there are so many outdated examples around that I spent half the time trying something that obviously didn’t work any longer because the approach had been revised.

Number 2 - class syntax has a lot of weird restrictions

Yeah, well… weird is perhaps not the right word, I admit. But it certainly seems weird, since they’ve just invented two entirely different sets of valid elements for classes with implicit construction sequences and those without. Basically I had a class that was instantiated with a Window reference and hooked up to an event from that Window. Handling that event, the class was performing a calculation and then it was supposed to fire a property changed event.

Now, to fire the event correctly, of course I need a reference to the current instance, which for some reason is only available in members (those that use the “member” keyword), not in function values created using the “let” keyword. The reason for that is probably that the “let” elements are only valid in an implicit initialization sequence and as such they’re practically part of the constructor code. Still, it took a while for me to realize that, since in most languages there’s a reference to the current instance available in the constructor - it’s probably a good idea not to have that reference in the constructor, since it prevents calling members before initialization is complete.

Anyway, so my event handler for the Window event had to be a member itself, not just a function value as I’d had it before. The problem was that in this case I needed a reference to the current instance to even hook up the event, which wasn’t available to me because I was using a construction sequence.

There is a syntax for explicit constructors that allows creating a reference to the current instance. This is still implemented cleanly, because the syntax requires that first a constructor (not necessarily the same one) has to run and initialize all values, before the additional block is executed that can access the current instance. Using that syntax in conjunction with my initialization sequence wasn’t really working, so I had to convert my class entirely to using just an explicit constructor. That involves getting rid of all “let”s, using “val”s for all fields, can’t use in-place initialization and so on…

So, just in case anybody reads this who’s in a discussion mood - I’m aware that in the end it’s all my fault But it is pretty hard to figure out how this all works, I didn’t find it to be well documented anywhere, and the compiler messages are really crappy about half the time.

Number 3 - Buggy behaviour of the “new() = { … } then …” syntax

This is the syntax I referred to before. In general it works fine - only I found that the compiler is really anal about the formatting of the expression, at least in #light syntax mode. I tried it without the #light at some point and found that it was actually more tolerant - but I had other trouble with that (doesn’t warrant an entry here since I didn’t investigate in depth - basically my “class” and “end” keywords allegedly didn’t match up whatever I did) and so I switched back to #light. In the end I got it working by formatting like this - all sorts of variations easily break things.

  new(state: int) as x =
    { state = state;
      blah = "hi" }
    then
      x.state <- x.state * x.state

Number 4 - class type eating up “do” block behind it, in spite of indentation

I had my main code file formatted along these lines:

type MyClass =
  ... stuff in my class
	
[<STAThread>]
do
  ... stuff to get my app running

That’s what I had the whole time, and I guess an important detail might be that I had a “do” block in my class while I was using the implicit initialization sequence. Later I removed the “do” block, and when I finally got everything to compile without errors (that stupid formatting thing with the new() above took me quite a while), suddenly my application wasn’t doing anything at all anymore! I placed a breakpoint on the first line of the app start block and execution didn’t even get there.

I found the source of that problem by looking at the compiled app with Reflector. Surprisingly, my startup method was entirely empty, and the code in that “do” block, even though clearly indented to live outside the class, had been pulled into a static constructor for the class. Wow. I haven’t had the need yet to actually create a static class constructor in F#, but my guess is that it uses a similar syntax. Anyway, given the indentation it seems pretty clear to me that in this case this shouldn’t happen. Well, who knows…

Anyway, I fixed the problem by adding “class” and “end” to the class type, so my code looks like this now:

type MyClass = class
  ... stuff in my class
end
	
[<STAThread>]
do
  ... stuff to get my app running

Oh yeah - and why did I have that class in the same file in the first place? Well… I’ve previously blogged about some weird things with namespaces in F#, and apparently that wasn’t the end of it. I tried to move the class into a different file and put it into an explicit namespace, but whatever I did, the compiler insisted that it couldn’t see the class in that block of code that becomes the startup method of a Windows application. Yes, I had an “open” line in that file of course. Another thing to investigate further, since I have no plausible idea what was going on there.

namespace Sturm.MyNamespace
	
type ICommandLine = begin
  abstract member Parts: string list
end
	
type IPlugin =
  abstract member CanHandle: ICommandLine -> bool
  abstract member Handle: ICommandLine -> unit
	
type blah =
  val mutable dummy: int
  interface IPlugin with
    member x.CanHandle(commandLine) = false
    member x.Handle(commandLine) = x.dummy <- 1
  end
  new() = { dummy = 0 }

Yeah, I know - useless code. The point is that there are dependencies between the three types. So I was trying to move the interfaces into a different file, and suddenly the type blah couldn’t find the interfaces anymore. Interesting.

The solution to this is simple, but looks a bit stupid. At the start of my new file, I had of course repeated the namespace declaration namespace Sturm.MyNamespace, but that is not enough. Even though that puts all the types in the same namespace, it is still necessary to explicitely open the namespace as well, if you’re going to access elements that have been defined elsewhere for the same namespace. So I need this header in the file with the class type:

namespace Sturm.MyNamespace
open Sturm.MyNamespace

While I can see the logic behind that, it doesn’t seem like a very useful approach… perhaps I’ll figure out the reasons later, right now I’m glad I’ve found a solution.

I haven’t spent too much time trying to fix this issue, but switching the printer port back to the RAW protocol provided an immediate workaround - the delay is back, but I can print whatever I want. Pretty interesting, as I’ve printed probably a hundred documents since I first switched to LPR. No idea where this comes from… I guess I’ll just switch the protocols selectively until I find time to hunt down a real solution.

Update: I just noticed that even with the protocol set to RAW, it doesn’t work every time - it used to work just fine, no idea what happened…

Find the registration page for DDD Ireland here and the one for DDD Scotland here. Hope to see you all there!

1. Some applications run automatically when I log on to Windows
2. Some applications I run manually after most logins, like e.g. Outlook. I have icons for those in the Quick Launch toolbar.
3. I use SlickRun to run those applications I use most regularly, but which are not running all the time. The Quick Launch toolbar also has icons for some other things that I run occasionally - often enough so I want to have the accessible, but seldom enough to make me think I’m going to forget the name of a SlickRun command if I were to create one for them.
4. I use the Start Menu with its Search functionality to run things that I use rarely.

I see how this doesn’t seem like an intuitive system, but it actually is for me.

Now, the Start Menu on Vista is really weird… it has this nice Search feature, which is very useful, but occasionally I can’t remember what the name of some item is, so I actually expand “All Programs” - and that’s where things start to go wrong. The Start Menu is so horribly slow that it’s practically unusable - it sometimes takes 20 seconds or so to expand a folder in the All Programs list. Why? No idea. I’ve been noticing the same thing on a previous Vista installation on a different machine, so it doesn’t seem to be related to my installation. It certainly has to do with the number of applications installed, but then the old Start Menu always coped with that just fine and certainly my 160GB laptop hdd can’t be home to the Vista installation with the largest number of installed apps in the world, can it?

Another thing is that even with SP1 installed, working in the Start Menu is something that sometimes crashes Explorer. Again, no idea why - it happens either when clicking around in the All Programs hierarchy, or when entering a Search term and looking through the result list. It almost seems that it’s most related to the duration I have the Start Menu open, since I don’t think it happens when I just open it, quickly select something and close it again.

I tried switching back to the Classic Start Menu, which has a nice effect on performance the list of installed apps fills the entire screen, but at least it comes up within 2 seconds or so. But the Classic Start Menu doesn’t have any features, not even those it should have according to the Options dialog - apparently it’s supposed to “store and display a list of recently opened programs”, but it doesn’t. It also doesn’t show top-level Administrative Tools, Computer or Network entries and it doesn’t support Search.

As a result, both Start Menu implementations are really unusable, though for totally different reasons. Why don’t they ever get it right?

I know there are other launcher applications out there (apart from SlickRun), but I’ve found those lacking in simple ways - I don’t want such an app to take up a lot of memory if it’s going to be running all the time, and the command features that SlickRun has are really the absolute minimum of what I need. OTOH, SlickRun doesn’t support working with the Start Menu content, which seems like a pretty useful and simple idea. Perhaps some other tools do? If I ever find time, this would be something to look into. If you know something I don’t, please comment and tell me!

First of all, here’s the download of slides and samples from the session: Functional Programming in C# 3.0 (718950 bytes)

Second, I’ve had a little thought about that example I was asked about during the session. It was one of the methods in the first basic example, and it looks like this:

public static IEnumerable GetAllMembersFunctional( ) {
  return AppDomain.CurrentDomain.GetAssemblies( ).SelectMany(
    assembly => assembly.GetTypes( ).SelectMany(
      type => type.GetMembers( )));
}

The question about it is whether this is a “real” functional implementation of the functionality or not, given that GetAssemblies returns information that changes dynamically outside my own function. I first pointed out in the session that the example was of course about the implementation of the method, not necessarily about whether or not you would want to implement a function that does precisely this same thing, especially if you subscribe to the “pure” theory of functional programming.

The more important thing about this came to my mind a bit later, but it depends a little bit on perspective. From the perspective of the guy who implements this method, I could say “Of course this is entirely valid - I’m simply calling other functions to return information to me (even though those functions don’t take parameters, so perhaps the source of the data is just a little suspect). I’m not the one who makes the decision to actually retrieve the information from what might be considered unreliable shared storage.” On the other hand, the function in question (GetAssemblies) is a function from my “runtime libraries”, in the form of the .NET framework, and it could equally well be said that I have to be aware of the nature of such functions and whether or not they do something I don’t want to do, and perhaps make the decision not to use them.

In the end it all comes down to discipline again. Modern functional programming, especially when applied to real world problems, is rarely “pure”. There’s sometimes a necessity to deal with shared data and external state to solve real-world problems. Modern functional languages recognize that and provide the means to do it, thereby removing restrictions and pushing the problem back into the area of discipline. There are small steps being taken to remind you of that choice you made, like the fact that you need special keywords in F# to create mutable variables. But if it’s your choice to try to live without shared state, it’s also your responsibility to adhere to that choice as much as you can, and decide sensibly about situations where you can’t.

Functional Programming in C# 3.0 (718950 bytes)

Have fun!

Anyway, and more importantly, the computer worked. So good work on that, Sony, and the turnaround was good as well!

For some reason the support guys apparently found they had to restore the hdd to it’s factory state though - I don’t quite understand which part of replacing a motherboard necessitated that step, but there you go. Acronis TrueImage (great product, btw!!) spent a few hours restoring my complete disk image, and after that the system was running just fine again.

One thing I noticed was that Windows thought it was no longer activated on the machine - presumably because of the mobo exchange. I only noticed by chance though - three days to go before activation - and that’s not good. I might have been somewhere without an internet connection in three days, when suddenly my Windows stops working… why don’t they display a large notification dialog in such a case?

So, to summarize - it took one week from contacting Sony support to getting back the fixed device, plus the additional work required to get everything back the way it was. I’m not really disappointed by this, but still it has to be said that even in this most positive of outcomes there’s still a lot to be desired.

I went to Germany for Cebit on Friday, and in the late afternoon I received an SMS telling me the machine had been shipped back! No further information though. I tried tracking the package on my BlackBerry, but found that the DHL tracking website doesn’t find a BlackBerry web browser worthy of accessing that info. Tracking on the computer was somewhat impaired by the fact that while they’d sent me that SMS, I didn’t have the same info as an email. Hm. Also, even though I had a case number from Sony, I wasn’t able to find any status info about the case on their support page - I do have an “eSupport” account there, but the case wasn’t listed in there.

Anyway, tracking tells me that I should receive the package today (Monday 9th), so I’m hopeful - assuming everything’s really fine with the machine, that would be a pretty good turn-around.

Here’s the download of slides and samples from that event:

BusinessAppsWithWPFScottishDevs.zip (1229546 bytes)

Update: I noticed that the slides were not in the download - my apologies about that, it’s corrected.

Have a look at my MVP profile here.

You’ll see that in a lot of profile entries for speaking engagements, the string “RETIRED — DO NOT SELECT” is shown. Why is that? Very simple: at some point the selection “.NET”, for instance, was a valid one, but now it had to be changed. Of course there are approaches to retiring data that would have left the old strings in place, but then those mechanisms introduce considerable overhead in the data gathering process. As the strings that are shown now also include the old strings, there was no conceivable reason not to go the easy way.

Thanks to the unknown delevoper/db admin who published this great sample!

Anyway, here are the downloads for my sessions (some of them together with Ian Cooper):

C# 3.0 Workshop - Everything you need to know about C# 3.0 (1551978 bytes)

Einfuehrung zu C# 3.0 (1168992 bytes)

C# 3.0 - Interessante Use Cases ausserhalb von LINQ (644553 bytes)

Extensible LINQing (402259 bytes)

The future of C# and other .NET languages (838316 bytes)

So I called Sony support this morning, since the machine is still in warranty. The guy had me go through a few steps and asked a few questions, but I’d tried the obvious things already - took out the memory sticks and popped them back in, tried using just one of them at a time, tried to run with and without the battery (and a second battery as well) and with and without the power adapter. Tried switching the Stamina/Speed switch, which also switches from primary to secondary graphics hardware on this device. All to no avail. He had me take out the battery and hold the power button, “in case there’s static built up in the machine”. Any scientific background to that one? I don’t know. In any case, it didn’t help.

So he said he could arrange for DHL to come pick up the machine tomorrow, which is nice. Having the original packaging (which I don’t) is apparently not important, nor is having any packaging at all (which I might have had), since the DHL guy is supposed to have “a box and a plastic bag” available when he comes here to collect. I hope the guy knows that

Then we moved on the topic of backups. I do have nice and current data backups and I’m already (more or less) up and running on my old Acer machine, so I thought that wasn’t going to be a problem, until he informed me that the tech guys may well have to restore the hdd to the base state of that system. He wasn’t able to tell me why they would do that, assuming the hdd isn’t broken of course, and although he went away to confirm, he said they couldn’t promise to call and let me know before they considered doing that either.

So I said okay, I’m going to take out