liam_on_linux | Entries tagged with classic

[Repurposed from a reply in a Hackernews thread]

Apple looked at buying in an OS after Copland failed. But all the stuff about Carbon, Blue Box, Yellow Box, etc. -- all those were NeXT ideas after the merger. None of it was pre-planned.

So, they bought NeXTstep, a very weird UNIX with a proprietary, PostScript-based GUI and a rich programming environment with tons of rich foundation classes, all written in Objective C.

A totally different API, utterly unlike and unrelated to Classic MacOS.

Then they had to decide how to bring these things together.

NeXT already offered its OPENSTEP GUI on top of other Unixes. OPENSTEP ran on Sun Solaris and IBM AIX, and I think maybe others I've forgotten. Neither were commercial successes.

NeXT had a plan to create a compatibility environment for running NeXT apps on other OSes. The idea was to port the base ObjC classes to the native OS, and use native controls, windows, widgets etc. but to be able to develop your apps in ObjC on NeXTstep using Interface Builder.

In the end, only one such OS looked commercially viable: Windows NT. So the plan was to offer a NeXT environment on top of NT.

This is what was temporarily Yellow Box and later became Cocoa.

Blue Box was a VM running a whole copy of Classic MacOS under NeXTstep, or rather, Rhapsody. In Mac OS X 10.0, Blue Box was renamed the Classic environment and it gained the ability to mix windows with NeXT windows.

But there still needed to be a way to port apps from Classic MacOS to Mac OS X.

So what Apple did was go through the Classic MacOS API and cut it down, removing all the calls and functions that would not be safe in a pre-emptively multitasking, memory-managed environment.

The result was a safe subset of the Classic MacOS API called Carbon, which could be implemented both on Classic MacOS and on the new NeXTstep-based OS.

Now there was a transition plan:

• your old native apps will still work in a VM

• apps written to Carbon can be recompiled for OS X

• for the full experience, rewrite or write new apps using the NeXT native API, now renamed Cocoa.

• incidentally there was also a rich API for Java apps, too

Now there was a plan.

Here's how they executed it.

1. Copland was killed. A team looked at if anything could be salvaged.

2. They got to work porting NeXTstep to PowerPC

3. 2 main elements from Copland were extracted:

• The Appearance Manager, a theming engine allowing skins for Classic MacOS: https://en.wikipedia.org/wiki/Appearance_Manager

• A new improved Finder

The new PowerPC-native Finder had some very nice features, many never replicated in OS X... like dockable "drawers" -- drag a folder to a screen edge and it vanished, leaving just a tab, which opens a pop-out draw. Multithreading: start a copy or move and then carry on doing other things.

The Appearance Manager was grafted onto NeXTstep, leading to Rhapsody, which became Mac OS X Server: basically NeXTstep on PowerPC with a Classic MacOS skin, so a single menu bar at the top, desktop icons, Apple fonts and things -- but still using the NeXT "Miller columns" Workspace file manager and so on.

Apple next released MacOS 8, with the new Appearance control panel and single skin, called Platinum: a marginally-updated classic look and feel. There were never any official others, but some leaked, and a 3rd party tool called Kaleidoscope offered many more.

http://basalgangster.macgui.com/RetroMacComputing/The_Long_View/Entries/2011/2/26_Copland.html

So some improvements, enough to make it a compelling upgrade...

And also to kill off the MacOS licensing programme, which only covered MacOS 7. (Because originally 7 had been planned to be replaced with Copland, the real MacOS 8.)

MacOS 8 was also the original OS of the first iMac.

Then came MacOS 8.1, which also got HFS+, a new, more efficient filesystem for larger multi-gigabyte hard disks. It couldn't boot off it, though (IIRC).

MacOS 8.1 was the last release for 680x0 hardware and needed a 68040 Mac.

Then came the first PowerPC-only version, MacOS 8.5, which brought in booting from HFS+. Then MacOS 8.6, a bugfix release, mainly.

Then MacOS 9, with better-integrated WWW access and some other quite nice features... but all really stalling for time while they worked on what would become Mac OS X.

The paid releases were 8.0, 8.5 and 9. 8.1, 8.6, 9.1 and 9.2 were all free updates.

In a way they were just trickling out new features, while working on adapting NeXTstep:

1. Rhapsody (Developer Release 1997, DR2 1998)

2. Mac OS X Server (1.0 1999, 1.2 2000)

3. Mac OS X Public Beta (2000)

But all of these releases supported Carbon and could run Carbon apps, and PowerPC-native Carbon apps would run natively under OS X without the need for the Classic environment.

Finally in 2001, Mac OS X 10.0 "Cheetah".

There have been multiple generations of Macs. Apple has not really divided them up.

1. Original 680x0 Macs with 24-bit ROMs (ending with the SE/30, Mac II, IIx & IIcx)
2. 32-bit-clean-ROM 680x0 Macs (starting with the Mac IIci)
3. NuBus-based PowerMacs (6100, 7100, 8100)
4. OldWorld-ROM PCI-based PowerMacs (all the Beige PowerMacs including the Beige G3 & black PowerBooks) ← note, many but not all of these can run Mac OS X
5. NewWorld-ROM PCI-based PowerMacs (iMac, iBook & later)
6. OS-X-only PowerMacs (starting with the Mirrored Drive Doors 1GHz G4 with Firewire 800)
7. 32-bit Intel Macs (iMac, Mac mini and MacBook Core Solo and Core Duo models)
8. 64-bit Intel Macs with 32-bit EFI (Core 2 Duo models from 2006)
9. 64-bit Intel Macs with 64-bit EFI (anything from 2008 onwards)

Classic MacOS was written for 68000 processors. Later it got some extensions for 68020 and 68030.

When the PowerMacs came out, Apple wrote a tiny, very fast emulator that translated 680x0 instructions on the fly into PowerPC instructions. However, unlike modern retrocomputer emulators, this one allowed apps to call PowerPC code, and the OS was adapted to run on the emulator. It was not like running an Amiga emulator on a PC or something, when the OS in the emulator doesn't "know" it's in an emulator. MacOS did and was tailored for it.

They ran Classic MacOS on this emulator, and profiled it.

They identified which parts were the most performance-critical and were running slowly through the emulator, and where they could, they rewrote the slowest of them in PowerPC code.

Bear in mind, this was something of an emergency, transitional project. Apple did not intend to rewrite the whole OS in PowerPC code. Why? Because:
1. It did not have the manpower or money
2. Classic MacOS was already rather old-fashioned and Apple intended to replace it
3. If it did, 68000 apps (i.e. all of them) wouldn't work any more

So it only did the most performance-critical sections. Most of MacOS remained 68K code and always did for the rest of MacOS' life.

However, all the projects to replace MacOS failed. Copland failed, Pink failed, Taligent failed, IBM Workplace OS failed.

So Apple was stuck with Classic MacOS. So, about the MacOS 7.5 timeframe, Apple got serious about Classic.
A lot of MacOS 7.6 was rewritten from assembly code and Pascal into C. This made it easier to rewrite chunks for PowerPC. However it also made 7.6 larger and slower. This upset a lot of users, but it meant new facilities: e.g. the previously-optional "MultiFinder" was now always on, & there was a new network stack, OpenTransport.

This is also the time that Apple licensed MacOS to other vendors.

Soon afterwards, Apple realised it could not build a new replacement OS itself, and would have to buy one. It considered former Apple exec Jean Louis Gassée's Be for BeOS, and Apple co-founder Steve Jobs' NeXT Computer for the Unix-based NeXTstep.

It bought NeXTstep and got Jobs back into the bargain. He regained control, fired Gil Amelio and killed off the licensing program. He also killed Copland, the experimental multitasking MacOS replacement, and got his coders to salvage as much as they could from it and bolt it onto Classic, calling the result MacOS 8.

MacOS 8 got a multithreaded Finder, desktop "drawers", new gaming and web APIs and more. This also killed the licensing programme, which only applied to MacOS 7.

MacOS 8.1 got a new filesystem, HFS+. This still works today and was the default up to High Sierra.

8.1 is the last release for 680x0 Macs and needs a 68040, although a few 68030 Macs work via Born Again.

The "monolithic" / "nanokernel" distinction applies to CPU protection rings.

These days this principally applies to OSes written entirely in compiled code, usually C code, where some core OS code runs in Ring 0, with no restrictions on its behaviour, and some in Ring 3 where it cannot directly access the hardware. IBM OS/2 2 and later uniquely used Ring 1. I've blogged about this before.

OS/2 2 using Ring 1 is why VirtualBox exists.

Decades ago, more complex OSes like Multics had many more rings and used all of them.

If a Unix-like OS is rewritten and split up sop that a minimal part of the OS runs in Ring 0 and manages the rest of the OS as little separate parts that run in Ring 3, that's called a "microkernel". Ignore the marketing, Mac OS X isn't one and neither is Windows NT. There are only 2 mass-market microkernel OSes and they are both obscure: QNX, now owned by Blackberry, and Minix 3, embedded in the control/management circuitry embedded into every modern Intel x86-64 CPU.

Classic MacOS is not a C-based OS, nor is it an Intel x86 OS. It does not have a distinction between kernel space and user space. It does not use CPU rings, at all. Everything is in Ring 0, all the time. Kernel, drivers, apps, INITs, CDEVs, screensavers, the lot.

MacOS 8.5 went PowerPC-only, and in the process of dropping support for 680x0 Macs, Apple made some provision for future improved PowerMacs.

The 68K emulator got a big upgrade to the emulator, now renamed a "nanokernel". It is not an OS in its own right: it boots and runs another OS on top of it.

It is not a HAL: this is native code, deep within an OS kernel, that allows the same OS to run with little modification on widely-different underlying hardware, with different memory maps, I/O spaces, APICs etc., without adapting the kernel to all the different platforms. MacOS 8.5+ only runs on Macs and the hardware could be adapted to the OS and the OS to the hardware. No need for a HAL.

It is not a hypervisor. A hypervisor partitions a machine up into multiple virtual machines -- it allows 1 PC to emulate multiple separate PCs and each virtual emulated PC runs a separate OS. Classic MacOS can't do that and only runs 1 OS at a time.

The MacOS nanokernel is a very small bit of code that boots first and then executes most of the rest of the code, and manages calls from apps from a 68K OS back to code written for the underlying PowerPC CPU.

It'sd a shame that this bit of code is secret and little-known, but some details have been leaked over the years.

Because I miss classic MacOS.

Unix is Unix. It's boring. It's everywhere. I run it on my desktop, my laptops, my phone, my tablet, my work PC. All different versions.

I dislike it less than the other options. I grew up on CP/M and VAX/VMS, then DOS, then Windows. At home, RISC OS.

I am not a programmer. Much of the stuff in Unix is irrelevant to me. I find its shell actively hostile, its filesystem an arcane mess that hasn't made sense since about 1973, its profusion of weird little config files, all in different formats, all to be carefully amended with various disgusting 1970s abominations of editors, to be a massive pain.

That's why my computer is a Mac. It needs less maintenance than almost anything else. My laptops run Ubuntu (and Haiku and A2/Bluebottle and IBM PC DOS 7.1). I rarely open a terminal if I can avoid it.

Classic MacOS is something else entirely. It's a thing of its time, yes, but it is a thing of great beauty. *The* single cleanest, most elegant GUI of any OS ever, from any time. No trace of a command line anywhere, not a single config file on the entire OS, and yet over 15 years it grew from something that ran in 128 kB of RAM on a 400 kB floppy to a multitasking Internet-capable OS on which I surfed the web, did my email, chatted to my friends on a half a dozen systems, did my invoicing, send data to & from multiple server OSes _and_ laid out magazines.

Its kernel wasn't elegant but there's more to life than kernels. It was the best-integrated general-purpose mass-market GUI OS the world has ever seen, and nothing ever even came close to its versatility. It was smoother and cleaner than ST GEM. It had a bigger better app selection than Amiga OS. It had a simpler yet more capable GUI than RISC OS. It made Windows or OS/2 look like sick jokes for a straight decade. And all this without any nasty dirty stinky mess of config files gluing it all together in the background.

I own a number of vintage Macs, and they're lovely, but there's no point in using PowerPC Mac OS X these days, because an Intel box does the same job better -- but it's not _really_ a Mac, although mine have gorgeous mechanical keyboards from the 1980s on them, naturally, because I'm a vintage computer fan and that's why I am here.

But the last _real_ Mac was the Beige G3 for me. It looked like a Mac, it talked ADB and AAUI and SCSI to the outside world, and it was visibly the same family as a Mac Plus from 1985.

(I gave my Blue & Whites away, which I slightly regret.)

Even my G4s aren't that Mac-like any more. They use PC stuff like USB and Firewire and PCI, which makes them cheap to run, but somehow a bit soulless.

The Mac was not just a computer, it was a culture, and it's one I worked with at the time but could't afford to use myself.

And whereas the ST and Amiga were cultures too, which I respect, I wasn't part of them then. I was an Acorn user then, but Acorns were barely usable on the Internet or on LANs. That stuff came after their decline and fall, for all that I have a Raspberry Pi with RISC OS on it.

Classic MacOS came from that era, but it survived and prospered and thrived into the Internet era of the Web and USB and multimedia.

That deserves anyone's respect.