"First problem: I don’t have a 16-bit code segment! Second: I don’t have a way to generate 16-bit code with GCC."
I had that exact same problem writing a loader for a now defunct OS and for years I kept a copy of Borland C++ handy so that I could compile a 16 bit trimmed down version of the filesystem that would load the rest of the OS before jumping into 32 bit mode. The tricky bit was that the loader had to interact with the BIOS in 16 bit mode and I could not find a way to cleanly jump back to 16 bit mode from 32 bit mode once I got there, so multiple transitions of that 16 to 32 bit boundary were out.
So instead I cut out everything from the filesystem code that had to do with writing and updating things just to read a couple of files, place them in memory, flip to 32 bit and then jump to the equivalent of 'init'.
The x86 compilers of old had a whole pile of 'models' that you could write for, all with different sizes of code and data segment limits.
DJ Delorie's excellent GCC to DOS port (DJGPP) was another very important tool in that whole process.
Also beautiful how web.archive.org provided one of the key bits of information, I suspect that in the longer term it will be as important as WikiPedia.
Ironically, the platform that the OP post itself has been published on results in a blank page when I submit it to web.archive.org and to archive.is.
OP if you are here, could you please repost your post elsewhere as well such as for example medium.com and respond with a link to it to me here so we (the users of HN - just to clarify that I have no affiliation with either of said archival services, I am just a regular user that submit URLs to them) can archive your post. It was an interesting post and I would like for it to be available in 1, 2, 5, 10 years.
The vast majority of what I (and my computer geek peers) did under OS/2 was run MS-DOS software in a multi-tasking environment. OS/2 never really got much in the way of quality native software developed for it, at least not that us poor students had access to anyways.
There was a file manager for Unix that was inspired by it – DFM – but not really the same thing, and the project seems to have died a long time ago. I remember using it with IceWM in Red Hat Linux 5.0 to get something vaguely OS/2-like. :)
What IBM needed was some killer OS/2-specific programs to attract the masses. There was a window (har har) of time where they probably could have done it, but they missed it. They certainly had the resources at the time.
It's also important to remember that PC hardware support was an absolute nightmare back then. OS/2 needed drivers written for everything, and very little was standardized, there wasn't even USB. Hardware compatibility combined with a lack of attractive native software were the major barriers to mass adoption IMHO.
This stroll down memory lane just reminded me of the pile of 30+ 3.5" floppy disks required to install OS/2, which I had to write myself using the CDROM from DOS, because OS/2 couldn't use that particular CDROM successfully yet.
IIRC, the main reason it caught on in banks was that those were big IBM customers to begin with, and that OS/2 offered good support for talking to IBM mainframes out of the box.
• Filesystem with long file names
• Buggy DOS programs couldn't crash the entire system
These sound silly and lame by today's standards, but you'd have to look at OS/2 through the lens of the late 1980's: The Apple Macintosh couldn't multitask anything and crashed all the time! DOS was a world where important files were stored in a directory called USPLDNGS or NODELETE. In the 1990s when Microsoft tried their hand at long filenames, we got gems like PROGRA~1
Microsoft and Apple didn't really solve any of these problems for consumers until 2001 (Windows XP and OSX) but it was already too late for OS/2 at that point.
It was better then Windows in every way except the fact that it as being sold and marketed by IBM. MS wrote the early code for it and it was going to be the next thing after Windows 3 but then they did NT.
I think it would have had a chance if it were easily config'd like the Mac, which was all graphical and simplified. But OS/2 was like DOS, requiring power users to edit config.sys and the like. Windows 95 provided more graphical config options, although in the end if you wanted to run games and the like, you were dealing with the crazy.
People were using Desqview in MS-DOS to achieve this level of multi-tasking in lieu of OS/2. OS/2 did it better. Windows 3.1 was cooperative multi-tasking, not even protected mode if memory serves.
Windows NT would be where MS tech caught up with IBM, OS/2 was out in the wild for quite some time already.
But the general public didn't embrace OS/2, Windows 95 effectively killed it.
OS/2 was originally a Microsoft/IBM joint product, work on NT at Microsoft began during that time as “NT OS/2”; the cooperation broke down in large part over the different directions MS and IBM wanted to take with OS/2.
They kept better architecture that could eventually be turned into a solid server. For time to market, they ditched the quality, high-availability, etc. They added a GUI. Backward compatible with DOS apps plus compatible with OS/2 stuff if I remember right. Tada! Eventually, added quality and security back in with SDL plus clustering. Bill had already achieved dominance at that point with OS/2 and every other desktop being an also ran.
Far as OS/2 goes, I read the original versions of NT were developed on OS/2 workstations that the developers gave up grudgingly when forced to dogfood on NT. They also used UNIXen for some server stuff and ran the business on a AS/400. They seemed to have just used whatever was best at each thing with long-term plan to replace it all with their competing product copying one, improving over others, and integrating some (i.e. open-source).
The core NT design with its kernel personalities is what allowed them to things like adding linux support, but in the book they describe there was so much pushback because it pushed ram requirements up to 8 mb (outside the abilities of consumer pc’s at the time) that Gates himself had to intervene several times to keep Cutler’s architecture intact.
I also really loved the bits about Cutler’s personality. They came across as more myth than fact but you do get the sense that working for him must have been a singular experience.
This in large part because of corporate and consumer demand for being able to run their existing software on new computers.
Something that both the FOSS world and others should take note of (and no, app stores do not remove this issue).
Now when it came to a massive DEC Alpha to run SQL Server, then absolutely. It was the ultimate hardware solution to a software scalability problem, and it was not cheap.
I think the word "clone" is too strong. DR-DOS is a clone of MS-DOS because it attempts to implement the same APIs, with the objective that most (ideally all) software written for MS-DOS would run on DR-DOS without modification. By contrast, Windows NT doesn't implement any of the APIs of VMS, and VMS software cannot run on Windows NT without modification. Microsoft did take people and high-level ideas from VMS, but they were never trying to build a clone of OpenVMS-which would require aligning API details (as opposed to just high-level concepts)
That code, while present in the codebase, was deactivated in the release version of Windows 3.1, so it actually ran just fine on DR-DOS.
You can read more, and actually run them here:
It's a little touchy to get the 1987 version running ( https://www.pcjs.org/disks/pcx86/os2/misc/football/87058/ ), but there it is, OS/2 1.0 hacked up with 32bit extensions to support multiple v86 machines. Windows/386 was a thing in 1987, along with Xenix on the 386. OS/2 could have been there too but IBM was too busy trying to cover base with the 5170, the brain dead 286 machine that dragged down the entire industry.
Between delaying the 32bit version for years, they also wouldn't let Microsoft just port over Windows to run ontop of OS/2. And of course SAA had to be 180 degrees opposite of Windows out of spite.
It's really no surprise that once Windows 3.0 started to sell, NT OS/2 3.0 suddenly became Windows NT 3.1
I'm under the impression OS/2 wasn't an attractive OS until 3.0 came along.
From your source: "Microsoft's internal project name for the new OS was OS/2 NT, because Microsoft's intention was for the new OS to succeed OS/2 yet retain the OS/2 API as
its primary interface."
Note how Russinovich talks about a "new OS".
The NT (kernel) never had any OS/2 code in it, it was a totally different project. The first target processor architecture for NT wasn't even x86, it was MIPS.
OS/2 in NT was merely a subsystem layer next to DOS and Posix, somewhat like today there is the Linux subsystem layer in Windows 10.
A good source is this:
I thought it's pretty well established now that the NT in the name was named after the target architecture: Intel i860 "N10", not MIPS.
The lasting benefit it seems to have as jaquesm said is reliability. Claim in article I doubt but shows they rarely crash:
"Oh, and another thing: OS/2, Waldhauer, says, doesn’t crash. It’ll run for a decade without requiring rebooting."
It's simple. It doesn't change a lot. It rarely crashes if that's to be believed. It's integrated into important systems for legacy effect. It also has at least one company at any given time updating it to work on modern stuff. So, that sounds like benefits a lot of big companies would be interested in. I think the drawbacks are too significant, though, especially it being a closed, barely-living tech without much of an ecosystem plus who knows what security or high-availability attributes.
Source: wrote whole systems in OS/2 Rexx!
IBM was the only company, after Lucid, that played with using a Smalltalk like development environment for C++ on OS/2, but it required too much resources.
OS/2 was one of the spiritual successors to DOS. It was DOS and Windows compatible, could run DOS apps in parallel and apps wouldn’t crash the whole system. It came with a reliable file system called HPFS as well.
Its direct competitor was Windows 95. It bet on better compatibility and better hardware support so eventually persevered. After switching to Windows NT kernel with Windows 2000, Windows had no technical shortcomings left compared to OS/2.
Still running 16 bit DOS and Windows programs meant that developers did not target an OS2 binary because a Windows binary was all they needed.