Why Does Windows Really Use Backslash as Path Separator?

Posted on May 24, 2019 by Michal Necasek

More or less anyone using modern PCs has to wonder: Why does Windows use backslash as a path separator when the rest of the world uses forward slash? The clear intermediate answer is “because DOS and OS/2 used backslash”. Both Windows 9x and NT were directly or indirectly derived from DOS and OS/2, and certainly inherited much of the DOS cultural landscape.

That, of course, is not much of an answer. The obvious next question is, why did DOS use backslash as a path separator? When DOS 2.0 added support for hierarchical directory structure, it was more than a little influenced by UNIX (or perhaps more specifically XENIX), and using the forward slash as a path separator would have been the logical choice. That’s what everyone can agree on. Beyond that, things get a bit muddled.

The only thing that is clear is that Microsoft and IBM were responsible for using the backslash as path separator in DOS 2.0. Microsoft reportedly wanted to use the forward slash as path separator, but IBM nixed the idea because it would have created an incompatibility with DOS 1.x, which already used the forward slash as a switch character, separating command options.

Microsoft old-timers all agree that IBM was strongly against changing the forward slash as a switch character. They are less clear on where that particular slash usage had come from.

There are silly theories about it, like “the slash came from CP/M”. Well, it didn’t. There is no real evidence that CP/M used the forward slash anywhere except the name of the product. Most CP/M commands had no options at all. Third party CP/M tools (such as Micrsoft’s) may well have used slashes, but not the OS itself.

There is obvious nonsense like “CP/M got the slash from VMS”, which is simply not possible because CP/M is older than VMS, and CP/M did not use the forward slash anyway.

SCP’s 86-DOS likewise did not use the forward slash. Which means DOS did not inherit the forward slash from its direct or indirect predecessors (86-DOS and CP/M). It must have come from somewhere else. Can we find out where from?

Continue reading →
Posted in DEC, DOS, IBM, Microsoft, PC history | 42 Comments

Developer Connection 9/11/12 Anyone?

Posted on May 20, 2019 by Michal Necasek

Recently I finally managed to put something on archive.org, namely images and scans of IBM’s Developer Connection for OS/2 CDs (called just IBM Developer Connection since Volume 10). My problem is that I don’t have any physical media for volumes 9, 11, and 12. I have some ISOs but especially Vol 12 is very incomplete.

Can anyone help with providing either media scans and ISOs or the physical media?

Posted in Uncategorized | 10 Comments

Pointedly Confusing

Posted on May 10, 2019 by Michal Necasek

While working on an unrelated problem, I stumbled across very surprising (to me) behavior of a C compiler. My code was the equivalent of the following: 

#include <stdio.h>
int arr[42];
int main( void ) {
     printf( "%u\n", sizeof( &arr ) );
     return( 0 );
}

The & operator produces the address of its operand, and if the type of the operand is T, the type of the resulting expression is pointer to T, at least in C89 and later. So the size of that type really, really should be the size of a pointer. Here’s what Visual C++ 1.52c, the last 16-bit Microsoft compiler, declared as ANSI-compliant, does with it: 

C:\temp>cl -W4 asz.c
Microsoft (R) C/C++ Optimizing Compiler Version 8.00c
Copyright (c) Microsoft Corp 1984-1993. All rights reserved.

asz.c

Microsoft (R) Segmented Executable Linker  Version 5.60.339 Dec  5 1994
...
C:\temp>asz 84

84? That’s the size of the array, not the size of a pointer to the array. Needless to say, that is at odds not only with any modern compiler (gcc, clang) but also with many other mid-1990s compilers (IBM or Watcom for example). What was Microsoft doing there?

Continue reading →
Posted in C, Microsoft | 9 Comments

1988 Networking: NetWare OS/2 Requester

Posted on May 10, 2019 by Michal Necasek

A while ago, the question of antique NetWare OS/2 requesters came up. The oldest known surviving NetWare OS/2 Requester is version 1.2, which is designed to work with OS/2 1.2. There are clear mentions of older requesters supporting OS/2 1.1 and possibly even 1.0, but nothing seems to have survived.

Except something did survive, in an archive called REL102.ZIP–not a terribly obvious name. Said archive contains the “OS/2 Requester Developer’s Release” from April 6, 1988 (a bit over 31 years old as of this writing). This was clearly not the first such release, and the oldest files are from February 1988. Given its vintage, it’s obvious that the Requester was designed to work with OS/2 1.0.

1988 NetWare OS/2 Requester utilities

There are several device drivers and a number of OS/2 utilities (SLIST, ATTACH, MAP, etc.); a notable omission is LOGIN (although LOGOUT is included), possibly because LOGIN.EXE normally lives on a NetWare file server.

Continue reading →
Posted in NetWare, Networking, OS/2, PC history, Virtualization | 16 Comments

NetWare 2.x Notes

Posted on May 9, 2019 by Michal Necasek

Novell NetWare has quite a long history, but the older parts of it are now almost completely lost. In the mid-1980s, Novell offered Advanced NetWare, NetWare ELS, NetWare SFT, and other members of the NetWare 286 family.

With the partial exception of so-called non-dedicated NetWare 2.x servers, version 2.x and later of NetWare always had dedicated server machines with clients (called “shell” in the old days, later “workstation”) for DOS, OS/2, Macintosh, and more.

There was not much to see on a NetWare 2.x server console

Until the mid-1990s NetWare typically used its own networking protocol called IPX. NetWare networks could use Ethernet, Token-Ring, Arcnet, IBM PC Network, and other physical network layers. In later days, NetWare networks were almost exclusively Ethernet based (as the other technologies died out), and over time increasingly switched to TCP/IP transport.

Continue reading →
Posted in NetWare, Networking, PC history | 14 Comments

LAN Manager 2.0 Primary Domain Controller

Posted on April 11, 2019 by Michal Necasek

While messing around with late 1980s and early 1990s networking software, I had the need to switch a LAN Manager 2.0 server to the primary domain controller role, so that it could run the Netlogon service and I could use clients which log onto the network. It was difficult enough that I needed to write it down.

It’s not that the process is undocumented, and I do have the complete documentation set on the Microsoft Programmer’s Library CDs. But the documentation is quite difficult to find (even though the Programmer’s Library is decently searchable) and somehow not very clear.

First of all, there are of course two ways to do it, either from the full-screen user interface or from the command line. I will skip the UI part because clicking around is harder than running a few simple commands.

I will just note that when on the server machine, running NET is not the same as NET ADMIN, even though the interface looks deceptively similar, and in fact the initial screen is 100% identical:

LAN Manager 2.0 NET or NET ADMIN screen

But with NET ADMIN, there are additional options in the UI. Here is the Accounts menu when running NET:

Continue reading →
Posted in LAN Manager, Microsoft, Networking | 3 Comments

Kryofluxing PC Floppies

Posted on March 16, 2019 by Michal Necasek

Last year I finally bought a Kryoflux, unfortunately in the middle of moving house. Now I’m finally able to use it beyond verifying that it’s not completely broken. After imaging a few dozens of floppies, I can say one thing–Kryoflux is surprisingly difficult to use with PC 5¼″disks. There is a distinct impression that Kryoflux was designed to deal primarily with Amiga and C64 floppies, and although PC floppy formats present absolutely no difficulty for the Kryoflux hardware as such, using the software for archiving standard PC 5¼″ media is very far from simple.

Let’s start with the easy part. Imaging 3½″ media is relatively simple because PC 3½″drives are straightforward (well, let’s omit the special Japanese 1.6M media). 3½″ drives always rotate at 300 RPM and usually automatically handle media density based on the floppy itself. But if everything were easy, life wouldn’t be very interesting.

Continue reading →
Posted in Floppies, Kryoflux, PC hardware | 11 Comments

Small World

Posted on March 3, 2019 by Michal Necasek

The core of this story was originally a private e-mail, but I realized that it’s worth sharing with a slightly wider audience.

Readers may know that I’m very interested in the history of PC development tools, especially C compilers, and especially the Watcom C compilers. I therefore know that Watcom C/386 7.0 (1989) was the first Watcom 32-bit C compiler, and in fact one of the first 32-bit compilers for DOS. The first was probably MetaWare High C, which was never terribly popular due to the fact that it was both quite expensive and quite weird; it just never fit into the world of PCs all that well.

The Watcom C/386 7.0 compiler on the other hand was a close relative of Watcom’s award-winning 16-bit DOS compiler (versions 6.0, 6.5, and 7.0) which maintained a good degree of compatibility with Microsoft’s C compilers, and was therefore not nearly as alien as High C. Andrew Schulman took a look at the 386 compiler in a 1990 DDJ article.

Continue reading →
Posted in PC history, Watcom | 16 Comments

Reading From Void

Posted on February 21, 2019 by Michal Necasek

Recently I came across the following question: What happens when software reads the registers of a non-existent IDE controller? That is, what happens when software reads for example ports in the 1F0h-1F7h/3F6h range (primary IDE channel) when there is no device on that channel?

For the vast majority of devices, the answer is simple, reads return with all bits set (0FFh). That’s when no device decodes the given address, i.e. no one claims the bus cycle/transaction. But IDE is different, because there often is a device which decodes those addresses, namely the IDE controller, usually on the motherboard within the southbridge chip.

The answer then might be buried somewhere deep in the Intel ICH datasheets or similar documentation. But it’s not.

Continue reading →
Posted in BIOS, IDE, PC hardware | 10 Comments

Ancient NetWare OS/2 Requesters?

Posted on February 16, 2019 by Michal Necasek

Quite a while ago there was a discussion on this site about NetWare support for OS/2 versions prior to 1.3. Finding reliable information is difficult, especially when one doesn’t know exactly what to look for.

Spurred by the discovery of Novell NetWare 2.15 ELS II in my basement (obviously I knew it was some NetWare stuff, but until I learned much more about NetWare 2.x I didn’t realize it was a complete NetWare 286 server kit), I started pondering the question again. The NetWare release I had included a separately packaged NetWare Requester for OS/2 version 1.2 from May 1990.

NetWare Requester for OS/2 v1.2

It is very unclear from the documentation what the version of the Requester itself is, or if it even has one, but it’s crystal clear that it’s for OS/2 1.2 only, not any earlier version (and OS/2 1.3 had not been released yet). It relies on NWIFS.IFS, an Installable File System, which means it can’t possibly work with OS/2 1.0 or 1.1, as there was no IFS support in those versions.

Continue reading →
Posted in NetWare, OS/2, PC history | 13 Comments