In praise of Windows Forms

Many of my personal projects such as DiskDigger, DiskImager, and so on are written using Windows Forms, on top of the Microsoft .NET framework. This is because these projects of mine were originally created many years ago during the heyday of Windows Forms, and I made somewhat of a gamble that WinForms would be a sustainable choice in the long term.

Fast forward to today, and it seems like mentioning Windows Forms in polite company evokes a chuckle or two. WinForms is now considered by many to be a quaint relic of a bygone era, which has been largely superseded by new and superior frameworks.

That being said, my old personal projects are still used by a good number of people, and even though I’ve added plenty of new features over the years, I haven’t changed a thing about the fact that they still use WinForms.  And even when I need to create a new GUI app for some random purpose today, I find myself reaching for a blank WinForms project.

So why do I still use WinForms in my personal projects, and why have I not abandoned it in favor of something newer like UWP, or something more cross-platform like Qt?

Because it bloody works. You might have noticed that support for Windows Forms in the most recent versions of .NET is as robust as ever, and in no danger of being dropped. This is because WinForms is an extremely solid foundation for building GUI apps. All of the components are intuitive, make sense, and feel native to the platform, because they are. If you don’t need any of the fanciness provided by XAML such as animating components at every opportunity, rotating buttons by 12 degrees, or making your app run on Xbox One, then WinForms is for you!

Because it’s an absolute pleasure to use. Creating a new Windows Forms project in Visual Studio takes four clicks at the most, and you’re up and running. Designing your app’s window is as simple as dragging and dropping components from a toolbox and adjusting their properties to your liking. Creating an event handler for a component is as simple as double-clicking it. There’s virtually no boilerplate code to worry about — just focus on the code that responds to a button click, ListView selection, etc.

Because it’s compatible and lean. Compatible in the sense of running across various versions of Windows, that is. If you target the right version of the .NET framework, your WinForms app will run perfectly well on Windows XP as well as the latest build of Windows 10. As for leanness, a “hello world” graphical app is on the order of a few kilobytes, and even a hugely complex app would be hard-pressed to exceed a few megabytes of bytecode.

Compatibility (or lack thereof) with other operating systems is, of course, the major unfortunate drawback. This is where my original gamble from years ago didn’t pay off as much.  Since .NET was touted as a “cross-platform” framework, I thought naively that components like WinForms would eventually be ported over to Linux and macOS in an official way by Microsoft. This never happened, and the only real “porting” was done by the excellent Mono project, whose port of WinForms is great but not perfect, and really only works in Linux and not macOS.

Nevertheless, despite the blemish of the lack of actual cross-platform support, WinForms remains a truly solid choice for desktop GUI development on Windows. Don’t be surprised if we keep seeing WinForms used by hobbyists and enterprises well into the future, and don’t hesitate to give WinForms a second look yourself. It might not be the shiniest new thing, but it has persisted this long for a reason.

Homeowner’s log, February 2021

Our steam heating has had some sporadic issues now and then, and I think I’ve finally got it solved once and for all. It’s all about the steam traps! If you have a two-pipe steam heating system, it’s very important to replace the steam traps every few years. Or rather, replace the internal component of the steam traps, which is the cage unit.

Failed or failing steam traps can cause all kinds of issues in your heating system, including radiators not warming up quickly, all kinds of noises around the radiators, and water hammering in the return pipes due to steam leaking into them.

And this time, I made a video about it!

Just for my own recollection in the future: most of the steam traps are Barnes & Jones #3045, and a couple are #122. Both of these types are compatible with the #1721 cage unit. However, one of the radiators has a #134 trap which requires a #1929 cage unit. In the future, if these parts become scarce enough, it looks like Tunstall has new replacement units that might be compatible.

Random thoughts 1

  • If your app has a “splash screen,” it’s a tacit admission that the app doesn’t load as fast as it should. If you build a splash screen into your app on purpose, you’re in the wrong field.
  • Programming languages are tools; they are a means to an end. There are very many programming languages. Don’t fixate on just one. It’s not particularly useful to become a great expert in any single language. It’s better to be adaptable and pick up a language for an application for which it will be useful. Unless you’re an actual hobbyist of language design, there’s really no reason to “master” a programming language for its own sake. What you should master are theoretical computer science concepts, and an instinct for where these concepts fit in real-world applications. Once you do that, it becomes easy enough to express those concepts using the language that best fits your task.
  • I would say I’m almost a libertarian, but not quite. Libertarianism seems to be predicated on the idea that individual people know what’s best for themselves. As I get older, I see that this is actually a very, very unsafe assumption. A good example is vaccinations: vaccinations have to be instituted and mandated at the federal level, lest the general public be swayed against them by less credible scientists like Marjorie Taylor Greene. Another example is education, especially education of science (viz. evolution). It’s probably better for school curricula to be composed at the federal level, instead of being voted upon by local communities of parents and teachers who grew up on the same nonsense that they teach.
  • When I reject the existence of a god, I’m not just rejecting the god, I’m rejecting the entire logical framework within which this god is constructed. So, as long as you continue to make arguments that are confined to that framework, you’re not adding anything new to the discussion. The fact that so many people in the world are religious says nothing about whether such a being actually exists; instead, it says something about human psychology.  It says something about these ancient psychological devices that we evolved during our prehistory as frightened primates struggling to survive and understand the world around us. It’s so trivially easy to reverse-engineer religion, and see exactly which buttons it pushes on the psyche, which emotions it appeals to, and what various uses it has for its practitioners, whether it’s for good or for evil.
  • The definition of “conservative” seems to be changing. Conservative used to mean wanting to go back to the old days, where “old” days could be fifty years in the past. But today you can be called a conservative for wanting to go back ten years, when ideas that were considered liberal at the time would be considered far-right today. It’s a bit of a problem when our moral universe changes within a human lifetime, and an even bigger problem when our moral universe changes with each new social media app.

How to recover data from QIC tapes

Simple: ask me to do it for you!

But if you insist on trying it yourself, here is a rough guide on the steps required to recover data safely and effectively from QIC-150 and QIC-80 cartridges.

QIC-80

First there is the matter of hardware. You’ll need to obtain a QIC-80 tape drive, such as the Colorado 250MB drive which was very common at the time. These are drives that usually connect to the floppy controller on the PC’s motherboard. There are a few types of drives that connect to the parallel port, but these are not recommended since they are much less compatible with various software.

Now you have a few choices. You may choose to take a binary image of the tape, which will be literally a dump of all the data on it. This can be done with Linux using the ftape driver.  Or you can attempt to use the original software that was used to write the tape. This would require you to stage the specific operating system and backup software, boot into it, and use it to restore the data from the tape.

Getting a binary image

This option is more straightforward, and also faster and more reliable, but the disadvantage is that you’ll need to manually decode the data and extract the files from it. Fortunately the data written to QIC-80 tapes mostly adheres to a single specification, and there are ready-made tools to decode this format.

To get a binary dump, you’ll need to boot into Linux. However, because the ftape driver has long been abandoned, it’s only available in very old distributions of Linux. The last version of Ubuntu that included ftape in the kernel was 6.06. Fortunately this version is readily available for download and can be used as a bootable live CD. Once it’s booted, you can load the ftape module by executing:

$ sudo modprobe zftape

This should create the appropriate logical devices that will let you access the tape drive. The device you’ll usually need is /dev/nqft0.

And to start reading data immediately, just execute dd as usual:

$ sudo dd if=/dev/nqft0 of=data.bin conv=sync,noerror &

Don’t forget the ampersand at the end, so that dd will run in the background and give you back control of the console.  The conv=sync,noerror parameter will make dd continue if it encounters errors and pad the output with zeros in case of a bad block. Although the skipping of errors hasn’t seemed to work very reliably with QIC-80 drives. If the drive goes into a loop of shoe-shining the tape for more than a minute, you should probably give up on that volume of the tape. Speaking of volumes:

The tape may consist of multiple volumes, which basically means that multiple backups were written to it in succession.  When your first dd call is complete, it will stop at the end of the first volume on the tape. But there may be additional volumes. You may call dd again right afterwards, which will proceed to read the next volume, and so on. You can also use the vtblc tool to see an actual list of the volumes on the tape.

You may also want to skip directly to another volume on the tape. This is useful if you encounter errors while reading one volume, and want to jump directly to another volume. I’ve found that the best bet is to perform a fresh boot, then skip to the desired volume, and start reading.  To skip to a volume, use the mt fsf command:

$ sudo mt -f /dev/nqft0 fsf x

…where x is the number of volumes to skip. So for example if you want to read the third volume on the tape, execute fsf 2 and start reading.

Note that the drive might not actually fast-forward as soon as you make the mt fsf call. It will usually fast-forward when you actually make the dd call to start reading data.

Using original backup software

If you want to go the route of using the original backup software that was used to write the tape, you’re now in the Wild West of compatibility, trial and error, and general frustration.  Most of the frustration comes from the old software’s incompatibility with modern CPUs (too fast) and modern RAM (too much).

Since the majority of these tapes were written during the DOS era, you’ll need to get a solid DOS environment going, which is surprisingly simple with today’s hardware. If your motherboard supports booting from a USB drive, it will probably be able to boot into DOS. This is because DOS uses the BIOS for disk access, and the motherboard provides access to the USB disk through the BIOS, so that DOS will consider the USB disk to be the C: drive.

There are a lot of different tape backup tools for DOS, but one that I’ve found to be very reliable is HP Backup 7.0. This software has recognized and recovered the vast majority of DOS backups that I’ve seen.  If this tool fails to recognize the tape format, try one of these other tools:

Central Point Backup

This is bundled with PC Tools 9.0. This is another DOS-based backup tool, but it could write the backup in a slightly different format. However, there are very specific steps for getting this software to work.  It does not work on modern (fast) CPUs because it relies on timing logic that causes an integer overflow. This can manifest as an “overflow” error or a “divide by zero” error.

To run Central Point Backup on a modern processor, you will first need to run the SlowDown utility from Bret Johnson.   I’ve found that these parameters work:

C:\> SLOWDOWN /m:25 /Int70

Note that this will cause the keyboard to become sluggish, and you might have some trouble typing, but it’s the only way.

NTBackup

Windows NT came with its own backup utility that could be used to write to floppy tapes. The trouble, however, is getting Windows NT to boot on a live modern system.  The goal is to get a boot disk that runs Windows NT Service Pack 6, which does in fact work well with modern hardware.  If you want to do this from scratch, you can try the following:

  • Connect a spare SATA hard drive (a real one) to your computer.
  • Boot into Linux and make sure to have qemu installed.
  • Run qemu, booting from the Windows NT install ISO image, and having the real hard drive as the emulated disk. For the initial installation, give qemu more modest parameters, including less memory (-m 256) and a lesser CPU (-cpu pentium).
  • After Windows NT is installed, power down the emulated machine, and copy the Service Pack 6 update executable onto the disk.
  • Power the emulated machine back up and install SP6.
  • You can then power it down, and you now have a hard drive loaded with Windows NT SP6, ready to be booted on real modern hardware.

Microsoft Backup (Windows 95)

Windows 95 is extremely tricky to get working on modern hardware, to the point where I would not even recommend attempting it. It may be possible to apply the AMD-K6 update patch, which supposedly allows it to run correctly on fast processors, and then apply the PATCHMEM update that allows it to support large amounts of RAM, but I have not had success with either of these. For me, Windows 95 is forever relegated to running in an emulator only. And fortunately I haven’t seen very many floppy tapes that were written using the backup utility from Windows 95.

QIC-150 and other SCSI tape drives

Reading data from QIC-150 tapes, or most other types of tapes from that time period, is slightly different from reading QIC-80 tapes, mostly because the majority of these types of tape drives connect to the SCSI interface of your PC. This means you’ll need a SCSI adapter that plugs into your motherboard. I’ve had a lot of success with Adaptec UltraWide cards, which are PCI cards, meaning that you’ll need a motherboard that still has older-style PCI slots.

And of course you’ll need a QIC-150 tape drive, such as the Archive Viper 2150, or the Tandberg TDC3660. Newer models of tape drives might be backwards-compatible with older types of tapes, but make sure to check the compatibility list for your drive before attempting to use it to read a tape.

Extracting the data from a tape is extremely simple using Linux. The most recent Linux distributions should work fine (as of 2020). If your tape drive is connected correctly to your SCSI adapter (and terminated properly using a terminating resistor), it will be detected automatically by Linux and should appear as a tape device, such as /dev/nst0.

To start reading data from the tape, execute the following:

$ sudo dd if=/dev/nst0 of=foo.bin conv=noerror,sync

See the previous section on QIC-80 tapes on further usage of dd, and how to read multiple volumes of data from the tape.

In my travels I have also seen tapes that have a nonstandard block size (i.e. greater than 512 bytes). This may manifest as an error given by dd such as “Cannot allocate memory.” In these cases, you can try setting the block size to a generous amount when invoking dd:

$ dd if=/dev/nst0 of=foo.bin conv=noerror,sync bs=64k

A large enough buffer size should fix the allocation error, but if you plan to use it with the “sync” option, then you must know the exact size of the buffer (i.e. the exact block size used by the tape). Otherwise the blocks will be written to the output file with padding that fills up any unused space in each block buffer. A common block size I’ve seen is 16k, especially in 8mm tapes.

Using original backup software

Of course it is also possible to use the original backup software that was used to write the tape. However, it’s much safer to obtain a binary dump of the tape in Linux first, before attempting to read the tape again using other tools. This way you’ll have a pristine image of the tape in case the tape becomes damaged or worn out during subsequent reads.

In many cases there are software tools that will extract the archived file collection directly from a binary image. But if these tools do not recognize the format of your tape image, you will indeed have to use the original software that was used to write it, assuming you can remember what it was. This can be quite difficult: setting up SCSI support in DOS can be a pain; the tape might not have been written using DOS at all, but something like Amiga, and so on. Regardless, the major hurdle is getting the data from the tape to the PC. Decoding the contents of the data is usually a minor detail.

…Or, if you don’t feel like it

I offer first-rate tape recovery services, at a fraction of the cost of other companies. Get in touch anytime and let me know how I can help!

Confirmation dialogs

Recently a friend of mine contacted me with an interesting issue.  He got ahold of a keyboard from an old PC workstation used with some legacy accounting software. But this was no regular keyboard — it was an Avant Stellar keyboard, in which all of the keys were remappable, and any key could be programmed with custom macros.

The original owner of the keyboard was no longer at the accounting firm, but my friend was very interested in determining what macros were assigned to each key, so that the accounting firm could use the old software more effectively, and hopefully transition away from it more easily.

I helped by managing to dig up the original software that shipped with these keyboards, which worked with MS-DOS and older versions of Windows. Here is what the software looks like:

Clearly this software is where the user gets to create their own macros and remap all of the key bindings. No less clearly, the software allows us to “Upload” and “Download” the mappings.  So, naturally, my friend thought the most sensible action would be to “Download” the current state of the keyboard and view all the macros in the UI of this software tool.  And so, he clicked the Download button, and… nothing seemed to happen. After a brief progress message, the interface stayed the same.

Now here’s the question: What does “upload” and “download” mean?  In 2020, download generally means “fetch something from an external source and save it onto the computer,” and upload means “send something from the computer to an external source.”  And you might think, in the context of this keyboard, download means “retrieve the current state of the keyboard onto the computer”…

But sadly, twenty years ago, the programmers of this software had the opposite definition of “download” in their minds.  Downloading meant loading the current mappings from the software onto the keyboard!

And even more sadly, the programmers didn’t include a prominent confirmation dialog that says, “CAUTION: this will load the new mapping onto the keyboard and overwrite any previous settings!”  And with a single click, the keyboard was overwritten without any warning or backup.  The only thing the programmers did was include a tooltip that appears when hovering over the Download button:

…but the tooltip appeared only after it was already too late.