Friday 23 December 2005

This much laughing hurts

I don’t often end up laughing hysterically at musical instruments!

In today’s feeds, an article from the Annals of Improbable Research blog linked to a Mr. Jay C. Easton, who plays the saxophone. Well, not just the saxophone, since there are many different types. Many more than the traditional four.

Including this monster.

There are some very smart saxophone makers out there, and the sound is actually pretty good. Well, except for the very lowest notes. I’m sure you can guess what they sound like, but there are plenty of clips on Easton’s site and Mr Eppelsheim’s. Another player, Fred Bayer, has had his Tubax modified to play much higher notes too (click on Tubax under Music in the navigation frame – a direct link takes you to the German language site).

Thursday 22 December 2005

Revisiting .NET CF Whinges

18 months ago, I wrote an article called “.NET CF whinging”. Now that Compact Framework 2.0 has been released, what’s been fixed?

  • I complained that only DrawLine was available, not DrawLines (which maps better to the underlying Polyline call). In .NET CF 2.0, you can now use DrawLines.
  • Previously, you could only create a one-pixel-wide pen. Now you can create pens of any width.
  • The System.Diagnostics.Process class has been added.
  • WaitHandle.WaitOne now offers a timeout overload. WaitAny is still missing.
  • Thread.Abort and Thread.Join are now present.
  • Control.InvokeRequired makes an appearance, and the Control.Invoke overload that takes an array of object parameters to pass to the delegate is now present. However, the documentation still contains a note that for .NET Compact Framework, you must use the EventHandler delegate, which only offers an empty EventArgs. This appears to be a documentation error – passing other delegate types and parameters does now work! The new BackgroundWorker class of the desktop Framework is not offered.

Rumour has it that the marshalling’s better in this version too.

HOWTO: Program Symbol MC3000 function keys

With my powers of intuition, I divine that someone out there needs to handle or program the function keys on the Symbol MC3000 device.

(Well, OK, it turned up in my referrer log – click the tracker icon at the bottom of the right-hand bar!)

The 28–key variant has F1 through F10 available through pressing the blue Func button and then the corresponding number key. The 38–key variant has F1 through F10 keys, then F11 through F14 on Func+F1 to Func+F4. The 48–key variant has F1 to F13 on Func+A to Func+M. (Nothing like consistency). When pressed, these will appear as VK_F1 through VK_F14 in your application’s WM_KEYDOWN and WM_KEYUP handlers or their equivalent in your environment (Control.KeyDown and Control.KeyUp events in the .NET Compact Framework, the value of KeyEventArgs.KeyCode will be Key.F1 through Key.F14).

That’s the default keyboard map. If you want to change the keyboard map, on any Symbol device, you need the Device Configuration Package for that device, which you can download from Symbol DevZone. In the package, you’ll find under Tools\kbtool a bunch of C++ files and a VC6 project. This is a program for your desktop computer which generates the keyboard map files. Open this with VC6 or later.

Each keyboard layout has (up to) three files associated with it – for the MC3000, MC3000KeynnM, R and S.cpp, where nn is the number of keys. The M file controls the multiple-press key operations, such as the mobile-phone-style input on the 28–key variant. The R file controls remapping key functions in different shift states. Finally the S file controls the scan code that’s output by each key – this is normally the one you want to edit. The available scan codes can be found in the accompanying ScanCode.h file.

Running the program generates the files that the keyboard driver is looking for. For the MC3000 these are named MC3000–{28,38,48}.{sct,rmt,mmt}. You can either overwrite these files in their normal location (\Platform\Keyboard) or modify the registry under HKLM\Hardware\DeviceMap\KEYBD to point to your version of the files.

We did this for New Look to make the two keys below the screen – with the red and green surrounds – perform ‘soft key’ functions in their applications.

Tuesday 20 December 2005

Do I look old to you?

I met up with some of the people from Channel 9 last Saturday – Dave Oliver, Barry Dorrans, Sarah Blow and Richard Peat (and his lovely wife Beth, who I don’t think has her own blog). Richard’s already written it up here.

Separately, Dave and Barry both told me that I looked older than my tender years (ahem) of 27, and suggested that I get rid of my beard. Barry also reckoned the ponytail should go (can’t remember what Dave thought but he did admit he’d had one when younger!)

For comparison:

Passport Photo

What I looked like in 1998, the last photo I have to hand of me with short hair and no beard (digital snapshot of my passport photo!)

2004

What I looked like last year (taken at my friend’s wedding in Toppenish, WA, USA).

The length of hair and beard varies. I was short-haired and clean-shaven at my graduation ceremony in 2001 and frankly I thought I still looked a bit too young in the photo (and very pale!) I’ve been letting the hair grow pretty much since then and it now just reaches the small of my back. I trim my beard every few weeks, normally when it starts itching too much – it’s quite short right now as you can see in Richard’s picture from Saturday where we’re attempting to play Barry’s card game Fluxx while waiting for food and/or Ian to arrive.

So, should I follow their advice?

Can the Windows Vista Network Map Control Panel detect a non-functioning switch?

Adam Nathan blogged today about some new features in the Windows Vista December CTP. One of them is a new Control Panel applet: Network Map.

Network Map applet

At work we commonly have problems with our switched network fabric. Sometimes after a power failure (a regrettably common occurrence at our location) the cheap 5-port switches at each desk will give all the signs of working, but not actually forward network frames – quite literally, “the lights are on, but no-one’s home.” Only power-cycling them gets them working again. Unfortunately there are chains of these in some places before reaching one of the wall sockets which connects to the main switch.

We also have a problem where, if one particular machine is switched on and connected, the entire LAN seems to go nuts, intermittently or permanently causing some routes to fail, unpredictably. We think this is due to the switches’ internal mapping of MAC addresses to ports somehow becoming incorrect, and forwarding packets to the wrong ports, or not at all. This is a mystery to all of us, especially since we’ve replaced the network card with a different model, tried it with different operating systems, tried it on a different wall socket, and repatched the wall socket/main switch connection. Nothing helps! If you have any ideas, leave a comment!

If this Network Map can tell you which device seems to be malfunctioning, that would be a serious boost to network administrators everywhere.

Monday 19 December 2005

Idiotic things to do

Look on Flickr for your own photos, from the machine you uploaded them from.

Doh!

Sunday 18 December 2005

The two-minute Xbox 360 and PGR3 review

I’m underwhelmed.

OK, that evaluation is based on playing a guy for one race on multiplayer on a demo pod yesterday. The shop was pretty loud and the console quiet, which made it not very involving. The rumble didn’t feel that great. The graphics are better than the current generation but actually not that much better than PGR2 – but I had a one foot view, not a ten foot view since the controllers are hard-attached to the pod. I think the screen was set up correctly but I don’t actually know.

We were lost in the game’s UI. Very lost. We ended up having a race with one computer car which zoomed off into the distance – and that was only on Medium skill. I lost – I kept crashing into the corners due to the lack of feedback from the game (audio and rumble), and lost when I crashed into the last corner on the last lap. I lost so badly that I didn’t even reach the finish line before the 30 second timer ran out after the computer car crossed the line (hence ending the game).

Maybe I should go back when it’s quieter and have a go at Career Mode.

Wednesday 14 December 2005

Coining a word

horricious (adj): Mind-numbingly awful. Descriptive of the speed of Microsoft’s first attempt at a ‘real’ Windows CE emulator.

A colleague asked if there was an emulator for one of Symbol’s hand-helds – a customer wanted to evaluate it with some software. While eVC 4.0 and VS.NET 2003 do ship an emulation platform, and Symbol supplies an emulator image for this platform, it is pretty slow. In describing this emulator to my colleague, I inadvertently coined this word. I’d just used ‘horrible’ and ‘horrendous’ and was searching for a third – lists of three, you know – and somehow got ‘horrific’ and ‘atrocious’ mangled together.

Oops.

The Pocket PC 2000 emulator, and earlier Windows CE emulators, ran weirdly compiled x86 code inside an app running on top of Windows. Stable it was not, and it didn’t emulate a CE device at all accurately. This made it completely unusable for actually developing apps.

The Pocket PC 2002 and later emulators were a little better. Now they were based on Connectix’ Virtual PC technology, which virtualises your PC’s processor and other resources (Microsoft bought out Connectix soon after). Unfortunately that’s still a virtualised x86, which is different from the actual Pocket PC 2002 devices, which use ARM processors. The result is that you had to do a special build for the emulator, meaning again that you’re not testing the same code you’re going to ship – and it was very hard to get libraries built for the emulator.

Windows CE on the x86 has always been a slug – Microsoft have never really taken it seriously as a platform, most hand-helds using MIPS or SH3 to begin with, then later ARM. Virtual PC wasn’t really designed to run Windows CE. Putting some form of Additions on the image would have been a) hard and b) defeated the object a little.

Visual Studio 2005 (at least, some editions) includes the Microsoft Device Emulator 1.0. This, finally, emulates an ARM processor. And you know what? It’s quicker than the virtualised x86! At last, it’s possible to use virtually a real OS image and real binaries in an emulated environment.

It’s still quite a bit slower than a real device though, even a 400MHz PXA255.

A rant on programming books

Matt Pietrek – he of the erstwhile MSDN Magazine column ‘Under The Hood’ – has an interesting post:

In a nut shell, there are a lot of books out there, and people are relying on them less and less as search engines become the dominant way to find information. It's pretty hard to pour massive amounts of work into something when you know most people just want the code snippet that gets them past their current problem. No actual learning required.

 ...and then they have no idea how the code works, so cannot adapt it to new requirements, or debug it when it doesn't work.

To me, a good tutorial is worth a thousand times a code snippet - although I do find that often MS Press books (at least, of a certain vintage) will print the entire source of a sample program which leads to the new stuff being lost among the boilerplate.

How new Windows programmers are supposed to learn what's going on when truly excellent books like Jeff Richter's "Programming Applications for Windows" go out of print I don't know. All abstractions leak, and I think you're better off understanding what leaks through the abstraction.

I only really ‘got’ MFC once I’d read “MFC Internals”, and understood the boilerplate that Visual Studio generates for a new MFC project.

Tuesday 1 November 2005

How media companies root your system

…and why you shouldn’t insert an audio CD into your computer if you’re running as an administrator: what Mark Russinovich found on one of his systems.

(If you’re not running as an administrator you, or software running on your behalf, cannot install a driver).

Tuesday 11 October 2005

MetaBlog: CAPTCHA enabled

Over the last week or so, comment spammers have found this blog. I’ve therefore turned on Blogger’s only security feature, word-recognition (sometimes known as CAPTCHA). It’s probably not enough to fool a determined comment spammer but I hope it will reduce it a bit.

I’ve also enabled ‘backlinks’ which I hope are just a Blogger name for referrers or some such.

Saturday 1 October 2005

Project Gotham Racing 3 videos

Some shakycam footage of a presentation of Project Gotham Racing 3.

Xbox360 News has six videos. They link to another which is still downloading as I write this.

I have to admit that graphically, it’s very, very good. There’s no substitute for actually playing it though. Looking at these videos does make me think that the game may well actually be ready for launch day – for an idea of software manufacturing schedules, note that Visual Studio 2005 is due to RTM on 14 October with physical product supposedly available on 7 November. In both cases the manuals and boxes can be pre-prepared, with only the DVD duplication required. Bizarre Creations still have probably a month to fine-tune the game.

There’s something worrying me. In the first video (actually the fifth link, named ‘pgr3gp1.wmv’) the menu has ‘Buy A New Car’ and ‘Sell Car’. I’ve played many games where you have to earn money to buy new cars and they’re universally a pain – you can never, ever afford a decent car, and the sale price is a small fraction of what you paid to buy it. It doesn’t look like PGR3 will have ‘repair’ requirements though, where you have to pay to repair your car. This was one of the many, many things that made Sega GT (a freebie with my Xbox) completely annoying and unplayable (on the other hand, the other freebie game, Jet Set Radio Future, is one of my all-time favourites and one of the major reasons I bought the console).

I recall that PGR2 has ‘Kudos Tokens’ which you earn by gaining a level, which you do simply by earning Kudos (basically by racing well or doing tricks like sliding the back end out or doing donuts, although I hope that’s easier on the new game). You unlock cars by exchanging Kudos Tokens, and in PGR2 you can’t sell a pony that you’ve bought. Having said that in PGR2 it’s rare that you’ll buy a complete dud because the car stats are pretty accurate (indicating that the Porsche Cayenne Turbo is by far the best SUV for example). As long as you’re not penalised too heavily for making a bad car choice, I’m happy. PGR2 also had a test drive feature but I’ll confess I never used it! PGR3 is meant to have much more level car sets, so there isn’t one ‘right’ car to use for a section of the game.

Here’s hoping they skip the American Muscle section this time. Last time out you’d got used to the nice-handling-but-a-little-slow cars in the early stages of the game, only to suddenly encounter cars which accelerate fast but lurch all over the place, and have no brakes to speak of. These cars were uniformly awful, there was no good one in the bunch. Making it through this section was a tedious slog, and it was a definite relief when I finished that section and could move onto some cars which, you know, handled.

Sunday 4 September 2005

What does the (VB.NET) ComClass attribute do?

A former colleague emailed me this week to ask about registering C# assemblies for COM Interop. He was convinced that you needed to do something special to advertise a COM object from C#, since we’d used the ComClass attribute in VB.NET. Also, Rockford Lhotka wrote (in July 2004):

“There are several COM interop features in VB that require much more work in C#. VB has the ComClass attribute and the CreateObject method for instance.”

I was able to assure him that for his scenario – late-bound use of an object – all you need to do is use regasm to register the assembly. That registers every public class in the assembly, except any that are marked [ComVisible(false)]. (A quick aside here – the registration time is longer the more public classes you have, so you should only make the classes you actually want to expose to COM public.)

But if regasm registers all public classes in an assembly, what is the ComClass attribute for? The documentation suggests it’s required but as we’ve just seen it isn’t, at least not for this scenario.

It’s a signal to the VB.NET compiler to do three things:

  • Emit an interface definition automatically generated from the methods and properties in the class – a so-called Class Interface.
  • Add this interface to the Implements list for the class (so the class appears to implement this interface).
  • Emit a <ClassInterface(ClassInterfaceType.None)> attribute to suppress auto-generation of a class interface.

That last one is interesting. The .NET Framework supports automatic generation of class interfaces at registration time using the ClassInterfaceAttribute attribute. That generated interface is either a dispatch-only or a dual interface depending on the type selected. So what’s the difference?

Let’s take a simple test:

Imports System.Runtime.InteropServices
<ComClass()> _
Public Class WithComClassAttribute
    Sub Test()
    End Sub
End Class
Public Class WithNoAttribute
    Sub Test()
    End Sub
End Class
<ClassInterface(ClassInterfaceType.AutoDual)> _
Public Class WithClassInterfaceAttribute
    Sub Test()
    End Sub
End Class

First, let’s look at the generated code with the help of Reflector (in C# mode):

namespace VbComTlbTest
{
      [ClassInterface(2)]
      public class WithClassInterfaceAttribute
      {
            // Methods
            public WithClassInterfaceAttribute();
            public void Test();
      }
      [ClassInterface(0), ComClass]
      public class WithComClassAttribute : _WithComClassAttribute
      {
            // Methods
            public WithComClassAttribute();
            public void Test();
            // Nested Types
            public interface _WithComClassAttribute
            {
                  // Methods
                  [DispId(1)]
                  void Test();
            }
      }
      public class WithNoAttribute
      {
            // Methods
            public WithNoAttribute();
            public void Test();
      }
}

Notice that VB has generated the automatic class interface as a nested type, inside the class it belongs to.

To see the difference from a COM perspective, we need to look at the type library. Export it using tlbexp, then use OLE View from the Platform SDK (also supplied with VS.NET) to load the type library (File/View TypeLib).

I’m not going to post the entire type library IDL shown by OLE View, but note that not setting an attribute generates an empty class interface definition (equivalent to setting ClassInterfaceType.AutoDispatch), and that setting AutoDual generates a class interface containing all inherited methods, including ToString, Equals, GetHashCode and GetType from System.Object.

So to duplicate VB.NET’s behaviour with the ComClass attribute in C# – if you need to, bearing in mind that this really only applies to early-binding scenarios – you need to define an interface then implement that interface, and use ClassInterfaceType.None. This (declaring interfaces) is, of course, what you have to do in traditional C++.

Monday 29 August 2005

Answering the mail - anatomy of a solution

I’m a bit slow in answering questions from the contact box. A couple of months ago, a commenter asked how the MC3000 application for New Look was implemented. Since we’re using this system as a case study it’s probably fair to post details if I don’t go into too much detail.

Actually I’m not sure where New Look’s name came up. I don’t think I’ve mentioned it here. It must have been some other forum.

As far as the MC3000 software goes, the main application is just Meteor Client. Meteor is our application server product which allows text-mode applications to be written using Windows-based desktop/server development tools – typically more rapidly than the equivalent handheld application. On this occasion, the four applications (Price Check, Stock Availability and the ancillary Menu and Head Office applications) were developed with Visual Basic .NET using a SQL Server 2000 data source. The total number of handhelds deployed is over 1200 I believe.

Meteor Client was originally written for Symbol’s Series 3000 DOS handhelds and the original/common code is written in C targetting a Symbol library called ADL and Symbol’s BiosXxx routines (wrappers around both the standard IBM PC BIOS interrupts and Symbol’s own BIOS features). It was ported to a Windows console application which is mainly used for development and testing although it has been used in deployment occasionally. It was also ported to PalmOS for the Symbol SPT 1700 and Monarch’s Pathfinder Ultra DOS device, although those ports are not currently maintained.

Meteor Client on Windows CE was originally targetted at Pocket PC-based devices such as the PPT 2700. I started the porting work about three years ago. Pocket PC devices don’t have console support and even if they did, the console would still – I think – have ended up with a certain amount of ‘furniture’ we didn’t want. Meteor Client is meant to be a locked-down application, no other applications can be used.

Without this console support, I had to provide all on-screen rendering. The only monospaced font I could rely on was Courier New, which I detest – it would be illegible at the screen sizes we need – and we needed the potential for custom font capabilities anyway. Therefore we use bitmapped fonts using bitmaps I drew, designed to use the maximum space available on the Pocket PC screen and others at two sizes, 8 rows by 20 columns (matching the PDT 3100) and 16 rows by 21 columns (matching the PDT 6800). Further fonts have been drawn to offer better displays on devices with different screen sizes – the MC3000 has a 320x320 screen which can all be used – and there are now 8 sizes ranging from a 9x9 pixel character cell up to a 15x39 pixel character.

The Windows CE port uses C++ for the Windows CE-specific code, and uses ATL for windowing support and a small amount of additional data structure support. MFC is overkill and I’d originally intended to do without it, but when it came to integrating barcode support I remembered that the code I’d written up to that point used bits of MFC since the new CE apps we were writing at that point were all written with MFC (the .NET Compact Framework wasn’t released until 2003). As part of the process to turn the port code into a separate library for porting DOS applications, I’ve eliminated this dependency.

Actually, the core of the porting library is really the keyboard buffer. Windows’ keyboard system requires that a window accept keyboard input messages. There’s a bit of a mismatch between the DOS behaviour, which made both scan code and character code available at the same time, and Windows, which generates a WM_CHAR message with the character code after the WM_KEYDOWN message with the virtual key code, but this wasn’t too hard to work around. Originally all the screen and keyboard code ran on the same thread as the application code, which meant that the screen didn’t update until you called either a keyboard wait function or a delay function, but I’ve recently – as part of the porting library effort – moved all the screen functions, and hence the keyboard functions, to their own thread. Cue some fairly complicated synchronisation code.

For barcode scanning I originally used a chunk of code that was, although slightly enhanced and made into a static library, some of the first code I wrote after graduating. Its main problem was that it only supported Symbol’s scanning APIs – it would run on a non-Symbol device but barcode scanning would be disabled. Over December to February 2002 we came up with a more abstract API that we call the Scanner Hardware Abstraction Layer, or ScanHAL for short. We now support Intermec and HHP’s APIs as well as Symbol’s, and have a package that can detect what device it’s running on and therefore install the right ScanHAL (there’s a null stub for devices with no scanner). This code is all C++ and, due to an error that was overlooked when building the first few versions, is tricky to use from C as all the entry point names are type-decorated (i.e. using the C++ linkage naming convention – we forgot to use ‘extern “C”’). We use this library, enhancing it as new features are required, in all our .NET Compact Framework applications too (if scanning is required). A colleague wrote the API and the initial version of the Symbol and Intermec HALs; I’ve enhanced both and wrote the HHP HAL, while Ian’s extended all the HALs at least once.

The New Look handheld software doesn’t just consist of Meteor Client though. There are a few other things too. Primary among them is support for firmware updates over-the-air (i.e. over the network). Symbol’s AirBEAM supports over-the-air upgrade but it doesn’t support scheduling an upgrade and for obvious reasons we didn’t want to push a firmware upgrade – which since they’re using the colour terminal is over 30MB – during work hours. Symbol do have a tool intended for making an update image on an SD card which we’ve adapted. Meteor Server pushes a notification of a new version to Meteor Client, which schedules the upgrade to occur at a random time within an administrator-specified time window. When that time occurs the updater program I wrote downloads the required files over HTTP (using the WinInet library), checks that the files downloaded correctly using the CRC32 algorithm, then runs our unpacker for Meteor Client and the other software, then Symbol’s updater. When the updater finishes successfully it cold boots the device which causes the new software to install. The install-after-cold-boot mechanism is another tool that’s evolved over my four years with the company – primarily my work.

To ensure that the update happens when the administrator wants it to, the device’s clock must be fairly accurate. Windows CE does supply a Simple Network Time Protocol client, but Symbol didn’t include that component in the MC3000 platform. We’d had trouble with its reliability on another device previously. I therefore wrote one myself, which took a couple of days – it’s less than 750 lines of C++ code (including blanks and comments) which includes converting from UTC to the local time zone since this part of Windows CE is often unreliable – it will tend not to take daylight saving into account, or do it twice. We therefore turn off the AutoDST setting in the registry – we update the clock every few hours anyway so being slightly wrong at the start and end of daylight saving doesn’t matter. It’s somewhat simplified code – the time is only computed to an accuracy of one second, which means no fixed point maths, and no roundtrip delay calculation is done. This provides plenty of accuracy for our purposes though.

The final part is the keyboard map. We do two things here: first, we map the two keys at the top of the MC3000’s keyboard which have, respectively, a green and a red surround so that they get key codes. The default keyboard map leaves them unmapped. These keys, being directly below the screen, are used as soft keys in the applications. Secondly, we found that since there’s no indicator light near the Alpha key, users could not tell when Alpha mode was active – we had a few support calls in the trial deployment asking why the handheld was simply beeping when any key was pressed, which was simply because Alpha was on. New Look use the 28–key keyboard. Style codes, colour codes and SKUs are all numeric, so there’s little need for alphabetic input, but the customer wanted to keep access to alphabetic characters for future applications. We therefore remap Alpha to a function key code and, in Meteor Client, toggle the on-screen keyboard when that key code is received.

That’s just the client side. This project, being the first to use multiple co-operating Meteor Servers to provide scale-out and failover capability, required some extensive work on the server side too.

Sunday 14 August 2005

Aaarrgh!

In my last post I said Microsoft would be releasing some official information on a topic that had caused plenty of FUD on forums. They haven’t yet done so. This is kind of annoying. The guy I was talking to hasn’t responded to my query about where the statement would appear. So the world – or at least, that part of the world that discusses these things on forums – carries on consuming and spreading FUD.

Some parts of the Windows team reacted very quickly to the suggestion that Monad could allow the spread of viruses. This team needs a boot up the backside, IMO. Scoble, are you listening?

OK, enough beating about the bush – I asked about OpenGL, and specifically this topic. Now I come to re-read the topic, it’s clear – if the app asks for accelerated pixel formats, and there is an Installable Client Driver available, Windows Vista will switch off the desktop compositor while the ICD is in use. What effect this will actually have I don’t know – presumably it will temporarily revert to using software desktop rendering, i.e. directing each window to draw in turn, clipping the parts that are obscured, as Windows has done for about 18 years (Windows 1.0 only allowed tiled, not overlapping windows). And of course you’ll only notice this if you’re using a windowed OpenGL app – full-screen apps (like games) will no doubt want the desktop compositor turned off!

The stuff about taking a 50% performance hit is simply FUD, IMO. The presumption is that translating OpenGL calls to Direct3D calls is expensive, but I don’t really see that. Numerous sites have had posters claiming that OpenGL is a more performant API than D3D, but without a program released for both APIs with as much time spent on both implementations, benchmarked on a range of hardware to eliminate driver variability, there really is no way to tell. I think the basis for this is essentially iD fanboys – since iD use OpenGL for their Quake, Return to Castle Wolfenstein and Doom 3 engines, it must obviously be better, right? I honestly don’t know, except to say that the games I’ve played have always seemed ‘fast enough’ if my system’s been within recommended spec, whatever API was used.

Wednesday 10 August 2005

If you want to know something, ask

Conspiracy theorists: if you want to know why Microsoft are doing something, try asking them.

I recently saw some information on forums that seemed wrong, so I did a bit of research and found a presentation that seemed to apply. Microsoft presenters normally put their email addresses on the cover, and this was no exception, so I emailed the presenter asking him to clarify a few points. I got a nice reply back which covered what I was after.

Yes, I know that’s very wooly. I asked if I could blog the conversation and he said no. However, there should be some official information appearing later today. When it does, I’ll update (if I remember).

When in doubt, ask. If they can’t say, they’ll normally say so.

Thursday 4 August 2005

Where's the damn SDK?

As I’m sure you’ve already seen, Windows Vista beta 1 was released about a week ago. This means I’m thinking about resurrecting my Changes to Win32 API in Longhorn series. Except, I can’t yet – because the SDK hasn’t been released yet!

Some kind of developer preview this is…

(Yeah, OK, the WinFX SDK has been released. But I’m still something of an unreconstructed Win32 guy.)

Loving the new monitor

I finally decided I needed more desktop space: both computer desktop, and the real desktop my monitor sits on – and this computer sits under. So I decided it was time to replace my old faithful Iiyama VisionMaster Pro 400 17” CRT with a flat panel. I looked at a number of sites and picked the ViewSonic VP191b 19” panel. So I can now use 1280x1024 comfortably.

It took a little while to adjust it to how I like it – colours seemed a little washed out – and it’s very bright. For tips on adjusting your monitor, see Charles Poynton’s article on ‘Brightness’ and ‘Contrast’ controls.

It cost a lot – nearly £400 after VAT and delivery – but I reckon it’ll last. It’s got something to live up to – the Iiyama lasted seven years with me, and is still going strong.

Thursday 14 July 2005

The Little Button That Could

Good story today on The Daily WTF.

The reason I posted this, though, was this fantastic comment: “It's like he tried to reinvent the wheel and some how came up with a Platypus or something.”

Tuesday 21 June 2005

No2ID Flair

Following Ian's example, I've added the No2ID PledgeBank petition flair to this site. It looks like this:

Click here to sign the no2id pledge

The counter updates with the number of people who have signed up. Meta: I need to think about moving off Blogger. Republishing the whole site (e.g. when changing the template) takes an age.

Tuesday 14 June 2005

Check your signatures and use precautions

I’ve had 24 copies of the I-Worm/Mytob.HI worm since 1am today. Either they’re sending to spam lists or there’s a lot of infections out there.

This one’s being sent with faked ‘From’ addresses, info@<domain>, admin@<domain>, service@<domain>, etc. Mostly the message is about account suspensions, password updates, etc. Don’t be fooled. Don’t open the attachments. 

Sunday 12 June 2005

Mac & PC - will the performance comparisons end?

From Paul Thurrott: a link to Java Rants, “Will partnering with Intel give Apple a Mac faster than a PC?

No.

Let me expand. The theory goes that the processor is laden down with years of backwards compatibility that costs performance – starting afresh with a special customised ‘x86’ with fewer instructions, without this backward compatibility, could improve performance. Apple’s ‘special’ x86s could then beat ‘regular’ x86s.

The trouble with this argument is that it’s bullshit.

The Pentium 4 does feature compatibility right back to the 8086. If the platform support is right, you can, it is believed, boot the original MS-DOS 1.0. But that doesn’t slow it down.

It’s correct that the core of the P4 is RISC-like, but only in the sense that the aim of RISC was to have very simple instructions that could be decoded by simple logic circuits which would execute on the core in one cycle. Modern ‘RISC’ processors are the same, effectively, as the core of the P4 – there are multiple execution units that can execute operations concurrently, in the same cycle. On the P4 there are two Arithmetic-Logic Units [ALUs] which can actually perform two operations per cycle – one on the first half of the cycle, the other on the second. The key is in how the instructions are decoded.

Simple x86 instructions are decoded pretty much as a true RISC processor would – using logic to directly decode an x86 instruction into a core-compatible micro-operation [µop]. The resulting trace goes in the trace cache – the P4 attempts to only decode a stream of instructions once, performing loops directly from translated instructions. Anything more difficult than this – say, indexed indirect memory loads with autoincrement – goes to a microcode ROM which contains a ‘program’ of µops to implement that x86 instruction. If the microcode program is greater than 4 µops in size, the execution core has to execute directly from the microcode ROM rather than the trace cache. I think that pretty much all of the clever out-of-order stuff is suppressed when this occurs. Hit a large instruction from ROM and the processor slows to a crawl.

Anyway, after that brief technical interlude, let me explain why removing backwards compatibility won’t speed up the processor. Because most of it’s implemented in the microcode ROM. I don’t know if you recall when the P4 first came out. A lot of commentators, running their tests on Windows 98, suggested that the P4 was actually slower clock-for-clock than the PIII. Guess why? Partly that code was optimised for the PIII which had different characteristics from the P4 – but also that Windows 98 still contained a lot of 16–bit code, which hit the microcode ROM.

If you don’t use the expensive instructions, you don’t incur any cost, particularly, for them being there. Presumably there’s a little more complexity in the decoder logic to determine that the instructions are in microcode.

People often make the same mistake with respect to Windows XP. They think that the existence of the DOS and Win16–compatible subsystems slows it down. Nope. That code lives in NTVDM.EXE and WOWEXEC.EXE, which aren’t even loaded unless they’re being used. I also need to be clear that the console window is not DOS. cmd.exe, the Command Prompt, is a 32–bit Windows application that uses the console subsystem. The difference between a console app and a Windows app is that a console app has a console created for it if its parent was not running in a console. What is a console? It’s a window which is created and updated by the CSRSS process. There’s some code in there to handle back-compat graphics but again this almost certainly isn’t loaded unless it’s being used. A lot of this has been ditched for Windows x64, but that’s because the processor doesn’t support virtual-8086 mode, necessary for this support, in so-called Long Mode (64–bit mode).

cmd.exe supports (I believe) all of the DOS command interpreter, command.com’s feature set, and extends it greatly. This, plus the command-line environment, leads a lot of people to be confused. Particularly when some of the system utilities, like more, exist as files named more.com. If you look with dumpbin or depends, you’ll see that more.com is in fact a Win32 console executable.

Speaking of x64, I note that Apple aren’t going straight for x64. Their Universal Binary Programming Guidelines [PDF, 1.5MB] talk about the 32–bit register set, not the 64–bit extended set. I expect that this decision is because the Pentium M with EM64T – codename ‘Merom’ – isn’t due out until late 2006.

This whole argument presupposes that Intel will make Mac-specific processors. I think that’s highly unlikely. Apple haven’t told us their motivations, leading to a lot of speculation. My view is that they are trying to both save money, by using a more commodity processor, and enable quicker access to newer technologies, by using more commodity chipsets (oh, and save money). It took them years to get AGP in Mac hardware, and it looked like taking even more years to get PCI Express. I don’t therefore expect Intel to produce ‘special’ processors for Apple – it’ll be stock parts or nothing.

Another reason for using stock parts is so that stock software tools can be used. Apple can mostly wave goodbye to maintaining their own compiler. It’s no accident that their guidelines state they’re using the System V i386 Application Binary Interface [PDF, 1.0MB], with only minor modifications. Of course, that means that to begin with, Apple will be using the very compiler – GCC – which they used to ‘prove’ that PowerPC G5s outperformed P4s, in that contentious set of benchmarks. Unless they’ve improved the optimiser, or learned how to use it properly, ‘PCs’ may well still outperform Macs.

One tiny area in which Macs may have a temporary advantage is in exception handling. Today, on 32–bit Windows, each use of an exception handler pushes a handler frame onto the stack, a cost incurred whether or not an exception actually occurs. I believe GCC uses a table-based scheme, which in general incurs that cost only when an exception occurs. However, Windows on x64 – indeed on every architecture other than 32–bit x86 – also uses a table-based scheme.

Saturday 11 June 2005

Passing the word

Want to keep your right, as a UK citizen[*], to privacy? Sign up for the No2ID pledge here.

Via Ian.

[*]Not a subject, dammit. I do not recognise the Queen as my ruler. Rulers are things you draw straight lines with – she’s a bit bumpy for that.

Saturday 28 May 2005

Watermark rendering bug in ListView

Or at least, in the ‘My Pictures’ folder in Windows XP Explorer. Try it yourself – ensure the watermark is enabled. Then right click and select ‘New Text Document’. Click to remove the rename highlight. Then select it again and press Shift+Del. Hit Yes.

If this reproduces on your computer, you’ll see something like this:

I guess the ListView code simply calls ScrollWindowEx to move any remaining lines up, but doesn’t take account of the watermark.

New technology plug: since Avalon is a stored graph system, it should handle this kind of thing for you. That is, you tell it what components make up your rendering – it renders the appropriate parts as required.

More Mobile Developer Shafting: Compact Framework 2.0 won't run on CE 4.x

I downloaded the Compact Framework 2.0 Redistributable yesterday as well, planning to do a little testing with one of our CF 1.0 apps. (I need to discover how to force using 2.0 if both are installed). In doing so I discovered that CF 2.0 only supports Pocket PC 2003 and Smartphone 2003, Windows CE 5.0 custom platforms, and Windows Mobile 5.0 (for Pocket PC and Smartphone).

That means that new devices, introduced this year, like Symbol’s MC3000 which runs a custom CE 4.2 platform, are not supported. Why aren’t Symbol using CE 5.0? Who knows. Maybe they didn’t want to revalidate all their components on the new OS yet.

Yesterday I was at the London Eye. They appear to use PPT 2800s with the optional trigger handle to scan the barcoded tickets. This device runs Pocket PC 2002.

Customers often want upgrades and/or new applications to run on existing hardware. We’d like to be able to use the newer tools to implement those upgrades or new applications. But we can’t, because those tools won’t run on the old hardware.

The full framework is compatible back to Windows 98. We can’t get three years’ worth of backwards compatibility in the mobile world.

.NET Framework 2.0 Compatibility

Brad Abrams: Take the .NET Framework 2.0 Compatibility Challenge.

I was at a slightly loose end yesterday afternoon, so I took advantage of that time to check that Meteor Server, and the price checking/stock availability application we wrote for a large deployment at a UK retailer, still work correctly under .NET Framework 2.0 Beta 2.

Meteor Server itself is mostly VB6 components – a server executable, an application-host component executable (ActiveX EXE in VB6 terminology), a few application-interface components which have strict binary-compatibility requirements – with a few bits of C++ where the VB6 environment really ran out of steam (TCP/IP printing, since TCP is a pain with the Winsock control, and a ‘callback’ component which replaces the use of minimum-delay timers). Applications are written as COM components. Recently – in the last couple of years – we’ve been writing new applications in VB.NET or C#. We’ve generally found that more productive than VB6. To do this we’ve built Primary Interop Assemblies [PIAs] for the application-interface components.

Meteor Server isn’t really .NET-aware. We do ship configuration files for the server and application-host executables, to force the latest version of the PIAs to be used. This allows older applications to run on a newer version of the server, without having to distribute the PIAs with each app, or all versions that have ever existed with Meteor itself. Remember that .NET binds to a specific version of an assembly, not to the most recently installed. We did try using Publisher Policy but had problems with it – sometimes the Framework would fail to load an application object, often crashing with an Access Violation in fusion.dll. Due to a misunderstanding in version numbers we had to ship multiple policy DLLs when using that scheme – one for every major.minor version of the PIAs we’d released.

Using explicit configuration reduces the frequency of this problem, but not to zero – we still occasionally see this in deployment, with Framework 1.1 SP1. It’s something of a heisenbug – it never happens when you’re looking for it. And a particular nightmare when dealing with VB6 code, because the VB6 debugger does not run your code as it will be run in deployment. Instead it hosts it in-process in the VB6 environment. You’re not even running the compiled code, I believe it translates the code to p-code and interprets that. While you can turn on PDB generation and debug with VS.NET or another native code debugger such as WinDbg, the generated PDBs are poor quality and don’t, for example, often include your local variables or globals properly.

Since it’s not really .NET-aware, the default behaviour of the Framework when loading into an unmanaged host applies – the most recent version of the Framework is loaded. We support loading alternate applications under application control in the newest versions of Meteor (I think the version currently available on our website is very out-of-date). The aforementioned price-checking application is actually implemented as four applications: a menu application which loads the others, the price-check application, the stock-availability application, and a head-office application which has testing features. This does mean that all applications will need to support the latest version of Framework, or the admin will need to tweak the config files to force all applications to bind to the older runtime.

Anyway, I’m pleased to report that there were no obvious problems using Framework 2.0 with any of these applications.

Thursday 19 May 2005

StarCraft: Ghost

How long have we been waiting for Blizzard’s StarCraft: Ghost? I can’t recall – I think they first announced it in 2001.

This week at E3 Blizzard have published new trailers and gameplay movies. I can’t help thinking it might be too little too late. What blew us away three or four years ago now looks a bit, well, ordinary. Halo 2 seriously raised the bar.

What’s been taking so long? I don’t know, but it looks like Blizzard have ditched their original partner Nihilistic Software, bought up a console developer, and brought the game back in-house.

The question for Blizzard: can they release this game before the next generation of hardware arrives and they look completely stupid?

Tuesday 17 May 2005

Xbox Backwards Compatibility

Xbox Backwards Compatibility

Now that it's been announced at E3, I can finally reveal that the Xbox 360 feature I work on is... Xbox backwards compatibility!

Yes, it's real. It's been fun to watch all the wild speculation over the past year or so as to whether the Xbox 360 would or wouldn't be backwards compatible. And all the wild ideas about how hard or easy it would be. It's clear that a lot of people have very little understanding of how these things work.

Were I forced to speculate, I’d expect some kind of JIT-compiler like the x86–on-Itanium IA32EL or the x86–on-Alpha FX!32 is involved. I can’t remember the old rule-of-thumb for emulation – was it that you should have a processor ten times as powerful as the emulated processor to reach parity? Of course that was for state-machine-based emulators, where essentially each instruction was executed in turn by emulating instruction fetch, decode, execute, retire.

Whether a particular Xbox game runs on Xbox 360 will depend on just how closely the assumed-JIT and its library emulate the original processor and, of course, GPU. Hopefully the fact that Jet Set Radio Future was a launch title and was bundled with some consoles (e.g. mine!) will be taken into consideration!

Monday 16 May 2005

Dammit, more incompatibilities

From Windows Mobile Platform Migration FAQ for Developers:

Starting with Windows Mobile 5.0, only one instance of the installer (wceload.exe) can be running at a time on Pocket PC devices. This restriction has always been in place on Smartphone. As a result, CAB files that start other CAB files from a custom setup DLL may not work on Windows Mobile 5.0. The workaround for this is to have a small executable in the CAB that a custom setup.dll starts in its Install_Exit entry point. This executable can get a handle to the running wceload.exe process, wait for wceload.exe to exit, and then restart wceload.exe on the additional CABs.

We have a pretty clever (says he who wrote it) technique of packing multiple CABs into one wrapper CAB file, which enables us to install Compact Framework, SQL CE, our barcode scanner hardware abstraction layer (ScanHAL), our simple large-key input method, and the application itself, all in one go. Looks like I’ll need to rewrite it slightly at the install-to-RAM stage.

Tuesday 10 May 2005

Well, I hope it takes a while before devices appear

Today, Microsoft announced Windows Mobile 5.0 (codenamed ‘Magneto’). They’ve made two bone-headed decisions from a development perspective:

  • ActiveSync 4.0 no longer supports TCP/IP synchronisation
  • According to this page, eVC 4.0 cannot be used to develop for Windows Mobile 5.0. You must use Visual Studio 2005.
  • Also, it seems you can’t use VS.NET 2003 to develop Compact Framework applications for WM5. Likewise, you must use VS2005.

The first can be worked around – you don’t need to use the ActiveSync transport or startup server for Platform Manager, but it’s a heck of a lot more convenient than using the TCP/IP Transport with the Manual startup server. With that combination you need to enter a horribly long command line (example: CEMGRC.EXE /T:TCPIPC.DLL /Q  /D:192.168.1.2:5913) on the device. VS.NET 2003 and 2005 do not use Platform Manager, though – trying to get both hooked up to the same device – as I tried to do today to actually view the contents of a memory block allocated in C# code, because opening the debugger memory window kills the debugging session – is highly problematic.

The second and third are idiotic. Hint to MS: VS2005 is not yet released! Yes, there’s a beta. No, I wouldn’t trust it for production development.

And there’s a new development. Mobile device development is a feature in the Standard Edition and above. It is not a feature of the Express Editions. Microsoft claim that there will be a Compact Framework SDK. Previously eVC was free. This made a big difference.

It’s not as if you can mix-and-match that well, either, because the current VS2005 beta apparently requires ActiveSync 4.0 – not actually released yet – in order to deploy to a device. Gee, thanks </sarcasm>.

Yup. Mobile developers get the shaft again. I’ve spent some time today trying to work out a way of avoiding getting blocked when calling InternetCloseHandle when a dial-up networking link has gone down. We seem to have the choice of either rebooting when blocked (enterprise app, so not completely out-of-bounds but undesirable, especially when the hardware cold boots when it was supposed to warm boot) or leaking handles, or rewriting to use WinInet asynchronously. WinInet isn’t well documented for the synchronous case, for the async case it’s downright abysmal.

Sunday 24 April 2005

How does a New submenu Command know where to create the new item?

On the command line, that’s how.

You must specify %1 in the command line somewhere, otherwise Explorer simply doesn’t do anything (it reports “Not enough storage to complete this operation”, an erroneous error message). The %1 is replaced by the full path to the file that would have been created.

Looking at Briefcase’s .bfc registry key shows that there’s also a second option passed to FormatMessage to create the command line, and it’s a number – the command line includes %2!d! which is indicative of the use of FormatMessage. It’s not clear what this second option means, however.

So that’s a step towards building our Burn Folders. Since our shell extension will be a DLL, we’ll probably include the New command as an entry point and use rundll32 to launch that. That keeps everything together.

Musings: How to produce a Burn Folder in Windows?

One of the new features in Apple’s Mac OS X ‘Tiger’ is ‘Burn Folders’ – a folder which you can easily write to a CD by selecting the ‘Burn’ option. It contains links to the files or folders to burn, not copies of the files. In other ways it’s just like any other folder. This allows the user to stage multiple CDs at once, and keep frequently-written CD data in an easy-to-write folder. How hard would it be to create one of these folders in Windows?

The Windows (Explorer) shell is extensible. One of the things you can extend is the shell namespace. The Recycle Bin is a shell extension. So is My Documents. A Burn Folder might therefore be something like Recycle Bin. It’s even more like a Briefcase, a feature much touted back in Windows 95 – it’s still there in XP, but its functionality is largely replaced by Offline Files for the situation where you’re taking your computer away from the office.

Let’s assume that when you create a Burn Folder, we actually create a real folder with that name with some special properties, and in it, when you drop an item, we store a Shell shortcut to the item you dropped. We should also support copy and paste, pasting links. By using shortcuts we should be able to leverage the Distributed Link Tracking service to keep track of where items are if you move the original file. I’m not sure what we do if the original file was removed – presumably we have to try to resolve all the links before starting to burn, and if some are missing we need to report that.

So, we have a namespace extension, and it sounds like we’re probably going to use a folder as the junction point. We’ll have to extend the New submenu to allow such a folder to be created (I guess we’ll have to use the Command option). We’ll have to modify the Explorer toolbar to show the Burn button. To address a complaint Paul Thurrott made about ‘Tiger’s Burn Folders, we should probably also modify the status bar to show the size of the linked files (i.e. how much space is required).

That covers the UI, then we have to be able to write to the disc. Here we’re pretty much stuck with just being able to handle CDs and writing them using the Image Mastering API.

This might be a fun thing to do. Something to add to my stack.

Saturday 23 April 2005

Full-screen is a new feature??

Paul Thurrott: Tiger math 2: When a feature isn't a feature

Apparently Apple are touting full-screen video playback as a new feature in QuickTime 7 in Mac OS X ‘Tiger’. Except that you actually don’t get it in ‘Tiger’, you have to pay for an upgrade to QuickTime Pro – the upgrade to the Pro edition of 6.5 cost $29.99.

In contrast, Windows Media Player has full-screen support out-of-the-box. I seem to recall that it has done ever since Media Player 6.4 on Windows 2000. Certainly the version of Media Player 6.4 that ships with Windows XP (run mplayer2 from Program Files\Windows Media Player), version 6.4.09.1130 on my computer, has this feature.

Scary...

On top, Emperor Palpatine from the Star Wars trilogy. On the bottom, Pope Benedict XVI.

Or is it the other way around?

Friday 15 April 2005

Tory posters defaced in Reading

Seen on Microsoft Typography news: Anger after Tory ads vandalised.

It wasn’t me, but I can understand why they were vandalised. The Tories’ whole campaign is based heavily on ignorance – xyz can’t be that hard, can it?

Yes, usually it can. I’m surprised – well, actually I’m not – that Labour and the LibDems have not actually rebutted how hard it is to do xyz.

Thursday 7 April 2005

Bring Back Chris Brumme!

Chris Brumme’s blog was one of the first I started to read, after Scoble, Chris Sells and Don Box. He’s managed a tricky task of explaining very complex subject matter (how the .NET CLR works) well.

Sadly he’s not posted in nearly a year, and the last entry was just announcing updates to existing articles.

So I’m joining Chris Anderson and Brad Abrams in saying:

Friday 11 March 2005

Putting things in perspective

Mozilla and all their fans, and FOSS people in general, are fond of saying that Firefox has had over 25 million downloads. Sounds like a lot, right?

I was on the Skype site earlier today. We use it at work in preference to calling mobile phones. (I was on the site because users were having trouble logging in – some kind of authentication server failure.) Skype are currently reporting 84 million downloads, and one million users using SkypeOut, the Skype-to-PSTN service.

Is Firefox really all that popular, then?

Monday 28 February 2005

MS Press, what are you thinking?

It looks like a couple of Jeffrey Richter’s classic and essential Windows programming books have gone out of print:

The .NET Framework and the C# programming language have huge productivity benefits, but there are times when you still need to get close to the metal. When you do, you need the best training possible. If you need to do it, those two books and Windows Internals, 4th Ed. are your best guide – IMO – to understanding what’s happening and how to make best use of the facilities at your disposal.

How to set the owner of an object in Windows XP

Normally, in Windows NT-family security, you cannot set the owner of a secured object (such as a file or folder, or a registry key) to someone else – you can only take ownership for yourself or a group you’re a member of. If you’re unprivileged you can only take ownership if the Discretionary Access Control List (ACL) gives you permission to take ownership. There is also a privilege – SE_TAKE_OWNERSHIP_NAME – which allows you to take ownership even if you’re not permitted in the ACL. This privilege is normally and by default only assigned to the Administrators group.

This ability to take ownership is in marked contrast to Unix where administrators can set ownership, but users cannot take it.

But what if you want to set ownership to a different user? If you try to execute this without any additional privileges, under I think any security principal, you’ll get an error. If you (like me) were using ADsSecurityUtility, it’ll be encapsulated in an HRESULT, code -2147023589 (0x8007051b). Anyone familiar with HRESULTs will recognise the 0x8007 high word as representing SEVERITY_ERROR | FACILITY_WIN32, i.e. a Win32 error code encoded as an HRESULT, so we can look up 0x51b = 1307 in WinError.h which is ERROR_INVALID_OWNER, “This security ID may not be assigned as the owner of this object.”

Looking this error code up in a search engine reveals the problem, that other people have had this problem before, and the fix. If you have the SE_RESTORE_NAME privilege enabled you’re permitted to set the owner of a secured object. Which makes sense, really, as you want restored data to have the same owner as it did when it was backed up.

Privileges come in two types – those which are enabled by default if they are permitted to a user (or a group of which the user is a member), and those which are disabled by default. Of the latter type, some Win32 APIs enable the privileges they require automatically. SE_RESTORE_NAME is not one; you must call AdjustTokenPrivileges to enable the privilege if not already enabled.

By default the Administrators and Backup Operators groups only have the SE_BACKUP_NAME and SE_RESTORE_NAME privileges. You can modify this and other privileges through Group Policy – for your own machine use the Local Security Policy shortcut in Administrative Tools. It’s really not recommended to modify these settings unless you’re absolutely certain you know what you’re doing. If you must, see under Security Settings > Local Policies > User Rights Assignment.

Sunday 6 February 2005

What a lovely birthday present

To whoever broke my driver’s door mirror, and didn’t leave a note:

Thanks for the wonderful birthday present. No, really. NOT!

I’m more annoyed because this time it’s not my fault.

My theory is that someone was going too fast down my road and got a bit close. It’s not as if they wouldn’t notice: the actual mirror is fine – still reflects the road behind me. It’s the fact that the only thing now holding it onto the car is a single clip on the facing plate – oh, and about two feet of gaffer tape. When I found it this morning it was basically hanging on by the three springs used to adjust the position. It might be possible to superglue it but I’ll try that at work tomorrow – I’m not standing out in the road doing it now. In future I’ll have to remember to tuck the mirrors in when I leave it. No-one else in the road seems to.

Part of the problem is that the end of what seems a fairly major road, just before it turns into the very major road, is in fact a bus lane – for all of about 50m – and is closed off to regular traffic, and the only warning of this is the sign a couple of metres before telling people to turn into my road. As a result this road is much busier than it should be.

(I’m 27.)

Friday 28 January 2005

New Location

Not for the blog, for me

After three and a half years living with my parents after graduation, I finally have my own flat. Well, I say my own - I'm renting. I could just barely afford to buy something around here, but only by completely bankrupting myself. It's furnished so I don't have that to worry about.

So far going OK but I'm back on the old modem again - my ADSL won't be connected until next Friday. I'd forgotten how slow this is! Actually I'm getting better connection speeds than ever before with a modem (got 52kbps yesterday) but it's still terrible.

I would have ordered the DSL before moving, but for some reason best known to themselves, BT decided to give me a different number from the previous occupants', which didn't appear in the DSL providers' databases until Tuesday.

Like most things in my life, I prevaricated for ages then sorted itself out pretty quickly. I was fairly happy living with my parents until recently. I think the trip to Seattle and environs in September, followed by a certain amount of independent living when my parents or my sister were away (pet-sitting in the latter case), plus a few weeks off before Christmas, reminded me a) that I could live independently and b) that I actually wanted to - I was going a little stir-crazy over Christmas.

It helped that I knew this flat was going to become free. The couple who lived here before are good friends of mine - indeed, it was their wedding I attended in Toppenish, WA back in September. I've known David since secondary school. He's now gone out to Bangladesh for Ph.D. fieldwork. By taking over the flat (new tenancy) I've saved myself the hassle of finding a place, the landlady's found a tenant easily, and we've both saved agent fees.

A lot of stuff is still in boxes - I only took last Friday off work, before moving in on Saturday - but it's getting unpacked slowly. As and when I can be bothered, mostly!

Reported Vulnerabilities in Pocket IE

It's not too surprising that Pocket IE suffers from some of the same flaws as the desktop Internet Explorer - it shares a certain amount of the same code.

One 'fix' that has made it into Pocket IE - at least for Windows Mobile 2003 Second Edition - that didn't in the end go into XP SP2 is patent-related. Yup, the Eolas patent workaround - if the page contains any scripted ActiveX controls, it pops up a dialog reading 'Press OK to continue loading this page.' Pretty annoying.