Liam on Linux

Not to blow my own horn, but, er, well, OK, yes I am. Tootle-toot.

I'm back writing for the Register again, in case you hadn't noticed. A piece a month for the last 2 months.

You might enjoy these:

Old, not obsolete: IBM takes Linux mainframes back to the future
Your KVMs, give them to me
http://www.theregister.co.uk/2015/11/02/ibm_linux_mainframes/

From Zero to hero: Why mini 'puter Oberon should grab Pi's crown
It's more kid-friendly... No really
http://www.theregister.co.uk/2015/12/02/pi_versus_oberton/

I have ruffled many feathers with my position that the touch-driven computing sector is growing so fast that it's going to subsume the old WIMP model completely. I don't mean that iPads will replace Windows PCs, but that the descendants of the PC will look and act more like tablets than today's desktops and laptops.

But where is it leading, beyond that point? I have absolutely no concrete idea. But the end point? I've read one brilliant model.

It's in one of the later Foundation books by Isaac Asimov, IIRC. (Not a series I'm that enamoured of, actually.)

A guy gets (steals?) a space yacht: a small, 1-man starship. (Set aside the plausibility of this.)

He searches the ship's crew quarters. In its few luxury rooms, there is no cockpit. No controls, no instruments, nothing. He is bemused.

He returns to the comfiest room, the main stateroom, i.e. cabin/bedroom. In it there is a large, bare dressing table with a comfy seat in front of it. He sits.

Two handprints appear, projected on the surface of the desk, shaped in light.

He studies them. They're just hand-shaped spots of light. He puts his hands on them.

And suddenly, he is much smarter. He knows the ship's position and speed in space. He knows where all the nearby planetary bodies are, their gravity wells, the speeds needed to reach them and enter orbit.

Thinking of the greater galaxy, he knows where all the nearby stars are, their masses, their luminosities, their planetary systems. Merely thinking of a planet, he knows its cities, ports, where to orbit it, etc.

All this knowledge is there in his mind if he wants it; if he allows his attention to move elsewhere, it's gone.

He sits back, shocked. His hands lift from the prints on the desk, and it all disappears.

That is the ultimate UI. One you don't know is there.

Any UI where there are metaphors and abstractions and controls you must operate is inferior; direct interaction is better. We've moved from text views of marked-up files with arcane names in folder hierarchies to today: hi-res, full-colour, moving images of fully-formatted documents and images. That's great.

Some people are happily directly manipulating these — drawing and stroking screens with all their fingers, interacting naturally. Push up to see the bottom of a document, tap on items of interest. It's so natural pre-toddlers can do it.

But many old hands still like their pointing hardware and little icons on screen that they can twiddle with their special pointing devices, and they shout angrily that it's more precise and it's tried and tested and it works.

Show them something better, no, it's a toy. OK for idly surfing the web, or reading, or watching movies, but no substitute for the "real thing".

It's a toy and the mere idea that these early versions could in time grow into something that could replace their 4-box Real Computer of System Unit, Monitor, Mouse and Keyboard is a nonsensical piece of idiocy.

Which is exactly what their former bosses and their tutors said about the Mac's UI 30y ago. It's doubtless what they said about the tinker-toy CP/M boxes a decade before that, and so on.

I'm guilty too. I am using a 25y old keyboard on my tiny silent near-unexpandable 2011 Mac mini, attached via a convertor that cost more than the keyboard and about a third as much as the Mac itself. I don't have a tablet; I don't personally like them much. I like my phablet, though. I gave away my Magic Trackpad - I didn't like it.

(And boy did my friends in the FOSS community curse me out for buying a Mac. I'm a traitor and a coward, apparently.)

But although I personally don't want this stuff, nonetheless, I think it's where we're going.

If adding more layers of abstraction to the system means we can remove layers of abstraction from the human-computer interface, then I'm all for it. The more we can remove, the simpler and easier and clearer the computers we can make, the better. And if we can make them really small and cheap and thus give one to every child in the poorer countries of the world — I'd be delighted.

If price was putting Microsoft and Apple out of business and destroying the career of everyone working with Windows, and replacing it all with that nasty cancerous GPL and Big-Brother-like services like Google — still worth it.

I do it myself. I wrote some get-started-with-Linux articles for the Register a while ago and got panned for that in the comments.

There are good reasons, though. It's just that all the n00bs and Windows lusers are scared of text, they want point-and-drool. ;-)

The things are these:

* with text, you can copy & paste - you can't do that with descriptions of click-this-click-that

* text is exact & unambiguous. Didn't work? You typed it wrong. 

* text is much much shorter. Full descriptions of GUI ops take pages.

Additionally, it's hard to describe icons unambiguously & most non-techies don't know what the words to describe GUIs mean: they don't know the difference between an icon and a button, or what a pull-down or listbox is. Give them very precise instructions & they can't understand them which they will adamantly deny. They will lie, cheerfully and repeatedly, and claim that things are invisible, don't exist, don't work, are not there, etc. because they would rather do that than admit that they do not understand the words you are using, because that would make them look stupid. They are not stupid - well, some aren't, anyway - but they will not admit that they use words without knowing what they mean and that they know nothing at all about the computer they spent thousands on.

Seriously. In my extensive experience in ~25yr in support, the majority of users do not actually know which bit the computer is. They may have paid as much as a small car but they don't know where it is. They think it's the screen, or in the keyboard, and never associate it with the footrest on the floor. They don't know they need electricity or cooling. They don't know what an operating system or a program is. But they glibly use terms like "hard disk" without the first notion of what they mean.

But they don't know that they don't know - Dunning-Kruger applies - and they will lie, long and loud and hard, rather than admit any
failing on their part. 

That's why the IT Crowd has the support guys put on a tape loop with "have you tried turning it off and back on again?" followed by "are you absolutely SURE it's plugged in?"

We all have heard stories like the urban legend about the American tourist melting a car's gearbox by driving hundreds of miles in 1st gear, not realising it is not an automatic.

Well, computer users are much much worse than this. They would drive backwards, or roll the car into a lake and sit on the bottom rowing it with oars, rather than admit that they don't know the difference between Microsoft Windows and Microsoft Word.

And that's why, rather than trying to describe what a volume icon is and what it looks like and where to find it and how to right click it, we say: "press Ctrl-Alt-T and paste in this line".

People don't like it, but it's short and it works.

I have spent a lot of time and effort this year on learning my way around the current generation of Windows Server OSs, and the end result is that I've learned that I really profoundly dislike them.

Personally, I found the server admin tools in NT 3 and 4 to be quite good, fairly clean and simple and logical - partly because it was built on LAN Manager, which was IBM-designed, with a lot of experience behind it.

Since Windows 2000 Server, the new basis, Active Directory, is very similar that of Exchange. Much of the admin revolves around things like Group Policies and a ton of proprietary extensions on top of DNS. The result is a myriad of separate management consoles, all a bit different, most of them quite limited, not really following Windows GUI guidelines because they're not true Windows apps, they're snap-ins to the limited MS Management Console. Just like Exchange Server, there are tons and tons of dialog boxes with 20 or 30 or more tabs each, and both the parent console and many of the dialogs containing trees with a dozen+ layers of hierarchy.

It's an insanely complicated mess.

The main upshot of Microsoft's attempts to make Windows Server into something that can run a large, geographically-dispersed multi-site network is that the company has successfully brought the complexity of managing an unknown Unix server to Windows.

On Unix you have an unknown but large number of text files in an unknown but large number of directories, which use a wide variety of different syntaxes, and which have a wide variety of different permissions on them. These control an unknown but large number of daemons from multiple authors and vendors which provide your servers' various services.

Your mission is to memorise all the possible daemons, their config files' names, locations and syntaxes, and use low-level editing tools from the 1960s and 1970s to manage them. The boon is that you can bring your own editors, it all is easily remotely manageable over multiple terminal sessions, and that components can in many cases be substituted one for another in a somewhat plug-and-play fashion. And if you're lucky enough to be on a FOSS Unix, there are no licensing issues.

These days, the Modern way to do this is to slap another layer of tools over the top, and use a management daemon to manage all those daemons for you, and quite possibly a monitoring daemon to check that the management daemon is doing its job, and a deployment daemon to build the boxes and install the service, management and monitoring daemons.

On Windows, it's all behind a GUI and now Windows by default has pretty good support for nestable remote GUIs. Instead of a myriad of different daemons and config files, you have little or no access to config files. You have to use an awkward and slightly broken GUI to access config settings hidden away in multiple Registry-like objects or databases or XML files, mostly you know or care not where. Instead of editing text files in your preferred editor, you must use a set of slightly-broken irritatingly-nonstandard and all-subtly-different GUIs to manipulate vast hierarchical trees of settings, many of which overlap - so settings deep in one tree will affect or override or be overridden by settings deep in another tree. Or, deep in one tree there will be a whole group of objects which you must manipulate individually, which will affect something else depending on the settings of another different group of objects elsewhere.

Occasionally, at some anonymous coder's whim, you might have to write some scripts in a proprietary language.

When you upgrade the system, the entire overall tree of trees and set of sets will change unpredictably, requiring years of testing to eliminate as many as possible of the interactions.

But at least in most installs it will all be MS tools running on MS OSs - the result of MS' monopoly over some two decades being a virtual software monoculture.

But of course often you will have downversion apps running on newer servers, or a mix of app and server OS versions, so some machines are running 2000, some 2003, some 2008 and some 2008R2, and apps could span a decade or more's worth of generations.

And these days, it's anyone's guess if the machine you're controlling is real or a VM - and depending on which hypervisor, you'll be managing the VMs with totally different proprietary toolsets.

If you do have third-party tools on the servers, they will either snap-into the MS management tools, adding a whole ton of new trees and sets to memorise your way around, or they will completely ignore it and offer a totally different GUI - typically one simplified to idiot level, such as a enterprise-level backup solution I supported in the spring which has wizards to schedule anything from backups to verifies to restores, but which contains no option anywhere to eject a tape. It appears to assume that you're using a robot library which handles that automatically.

Without a library, tape ejection from an actual drive attached to the server, required a server reboot.

But this being Windows, almost any random change to a setting anywhere might require a reboot. So, for instance, Windows Terminal Services runs on the same baseline Windows edition, meaning automatic security patch installation - meaning all users get prompted to reboot the server, although they shouldn't have privileges to actually do so, and the poor old sysadmins, probably in a building miles away or on a different continent, can't find a single time to do so when it won't inconvenience someone.

This, I believe, is progress. Yay.

After a decade of this, MS has now decided, of course, that it was wrong all along and that actually a shell and a command line is better. The snag is that it's not learned the concomitant lessons of terseness (like Unix) or of flexible abbreviation (like VMS DCL), or of cross-command standadisation and homogeneity (although to be fair, Unix never learned that, either. "Those who do not know VMS are doomed to reinvent it, poorly," perhaps.) But then, long-term MS users expect the rug to be pulled from under them every time a new generation ships, so they will probably learn that in time.

The sad thing about the proliferation of complexity in server systems, for me, is that it's all happened before, a generation or two ago, but the 20-something-year-olds building and using this stuff don't know their history. Santayana applies.

The last time around, it was Netware 4.

Netware 3 was relatively simple, clean and efficient. It couldn't do everything Netware 2 could do, but it was relatively streamlined, blisteringly fast and did what it did terribly well.

So Novell threw away all that with Netware 4, which was bigger, slower, and added a non-negotiable ton of extra complexity aimed at big corporations running dozens of servers across dozens of sites - in the form of NDS, the Netware Directory Services. Just the ticket if you are running the network the size of Enron or Lehman Brothers, but a world of pain for the poor self-taught saps running single servers of millions of small businesses. They all hated it, and consequently deserted Netware in droves. Most went to NT4; Linux wasn't really there yet in 1996.

Now, MS has done exactly the same to them.

When Windows 2000 came around, Linux was ready - but the tiny handful of actual grown-up integrated server distros (such as eSmith, later SME Server) have never really caught on. Instead, there are self-assembly kits and each sysadmin builds their own. It's how it's always been done, why change?

I had hoped that Mac OS X Server might counteract this. It looked the The Right Thing To Do: a selection of the best FOSS server apps, on a regrettably-proprietary but solid base, with some excellent simple admin tools on top, and all the config moved into nice standard network-distributable XML files.

But Apple has dropped the server ball somewhere along the line. Possibly it's not Apple's fault but the deep instinctual conservatism of network and server admins, who would tend to regard such sweeping changes with fear and loathing.

Who knows.

But the current generation of both Unix and Windows server products both look profoundly broken to me. You either need to be a demigod with the patience and deep understanding of an immortal to manage them properly, or just accept the Microsoft way: run with the defaults wherever possible and continually run around patching the worst-broken bits.

The combination of these things is one of the major drivers behind the adoption of cloud services and outsourcing. You move all the nightmare complexity out of your company and your utter dependence on a couple of highly-paid god-geeks, and parcel it off to big specialists with redundant arrays of highly-paid god-geeks. You lose control and real understanding of what's occurring and replace it with SLAs and trust.

Unless or until someone comes along and fixes the FOSS servers, this isn't going to change - it's just going to continue.

Which is why I don't really want to be a techie any more. I'm tired of watching it just spiral downwards into greater and greater complexity.

(Aside: of course, nothing is new under the sun. It was, I believe, my late friend Guy Kewney who made a very plangent comment about this same process when WordPerfect 5 came out. "With WordPerfect 4.2, we've made a good bicycle. Everyone knows it, everyone likes it, everyone says it's a good bicycle. So what we'll do is, we'll put seven more wheels on it."

In time, of course, everyone looked back at WordPerfect 5.1 with great fondness, compared to the Windows version. In time, I'm sure, people will look back at the relative homogeneity of Windows 2003 Server or something with fondness, too. It seems inevitable. I mean, a direct Win32 admin app running on the same machine at the processes it's managing is bound to be smaller, simpler and faster than a decade-older Win64 app running on a remote host...)

In the beginning were the dinosaurs: Erwise, Cello, Mosaic, Lynx and things. Nobody under 40 remembers them and they're all long extinct. Everyone used Mosaic anyway, which was FOSS from the NCSA.

Nobody's heard of the NCSA any more, which is a shame as they also gave the world Apache and without them there wouldn't be a Web. They made something useful out of Tim Berners-Lee's work at CERN, but timbl and CERN are far more famous.

Odd, really, that neither CERN nor the NCSA ostensibly have anything to do with the Internet.

Mosaic begat loads of different browsers. All were also called Mosaic. Many were proprietary, "enhanced" versions, which actually weren't.

Only one was any good. Called - surprise! - Mosaic, it came from a company also called Mosaic. (Are you following all this?) Developed under the codename "Mozilla" - the Godzilla of Mosaics, you see - it was Mosaic with embedded pictures and FTP and cool stuff like that. Hey, it was 1994. People complained about the confusing name so the company renamed itself Netscape and renamed their browser Netscape as well, which isn't confusing at all. It was shareware, vastly successful, created the original 1990s Web and was killed off by Microsoft giving Internet Explorer away for free.

But as Ben Goldacre likes to say so much that he has put it on a T-shirt: "I think you'll find it's a little more complicated than that."

For starters, IE 1 was an optional extra for Windows 95, you had to buy it, and it was utterly crap. IE, incidentally, is also based on Mosaic, via Spyglass. MICROS~1 didn't write IE themselves, they just bought it in. You'd be surprised how many "Microsoft" products were not actually written by Microsoft: Powerpoint, Visual Basic, SQL Server, Defender, Frontpage, Mail and lots of others.

IE2 was free, but still rubbish. So was IE3.

So everyone used Netscape. A few even paid for it and Netscape Inc did tremendously well. This pissed off Microsoft, who don't really like anyone else making big money off their platform. So they worked away on IE until eventually, after about four versions, it was actually just about usable, kinda sorta ish.

And it was freeware.

Netscape wasn't, officially. It went through various stages, including being free only for non-profits and educational institutions, but it ended up proprietary, closed-source shareware. Home and non-commercial or non-profit use was free, businesses were meant to buy licences. Which most didn't.

It went through a whole bunch of versions, all of which were market-leaders in their time.

Netscape 1 was just a browser.

Netscape 2 added an email client and USENET news-reader. Not RSS, what we call a news-reader today, that hadn't been invented yet. Netscape 2 was a fair bit bigger than Netscape 1.

Netscape 3 Gold added web-page editing too. It was bigger still.

Netscape 4 sort of forked, internally: there was Netscape Communicator, a suite including a browser + email + news + address book + web editor + a proprietary shared diary - a huge app for the times,

And separately, there was Netscape Navigator, which was just a browser once again and thus was relatively svelte and quick - so naturally it never got updated past 4.0.x.

In the end, once IE was usable enough, everyone used that instead. Netscape Communicator was big, sluggish, took loads of memory and was inefficient - and it cost money. For instance, every time the window was resized, it re-rendered the entire page, as the rendering engine built a static page display for the current window dimensions. This was at the time when live window resizing was a trendy new feature of Windows - it was an extra in the same Plus! pack for Windows 95 that introduced IE to an indifferent world, and had even been retro-fitted on to MacOS 8.

Netscape complained that IE, a rival for their commercial product, was being given away for free - which counts as illegal restraint of trade. In response, MICROS~1 just bundled it with Windows and blithely claimed it had always been there, even though it wasn't in Windows 95 or Windows NT 3 and they also offered it for Mac and Unix. The US Department of Justice, remarkably, swallowed this, even though it was demonstrably utter bollocks, and let MICROS~1 off.

When Netscape Corp was bought out by AOL and broken up, the company's last act was to make the as-yet-unfinished Communicator 5 open source under its original codename of Mozilla.

After more than two years of work, this eventually became the Mozilla Application Suite, also the basis for AOL's Netscape 6 and 7. Netscape 6 was based on the unfinished Mozilla 0.6 code, and Netscape 7 on the final but unpolished Mozilla 1.0. AOL then outsourced it; Netscape 8 was based on Firefox 1 and Netscape 9 on Firefox 2. All were freeware; Mozilla itself was FOSS.

Mozilla was the Linux browser. It was the best FOSS browser, but that was because it was also pretty much the only FOSS browser. It was also a huge big lumbering thing, like Communicator before it, and it was unpopular on Windows and Mac (although I used it myself, as I am not a big Microsoft fan, as you might have worked out.)

Then Dave Hyatt and some mates, including a chap called Ben Goodger, stripped Mozilla down to just a browser, reinventing Navigator as if it were a new concept. They called it Mozilla Phoenix. Rising from the ashes, you see.

Phoenix the BIOS people complained.

They renamed it Firebird.

Firebird the FOSS database people complained.

They renamed it Firefox, which is a made-up word and obscure enough that nobody minded. It did brilliantly and still is today. The Mozilla Foundation consequently abandoned the Mozilla Internet Suite. The legendary open-source community took it up, renamed it Seamonkey and it's still updated. I still use it occasionally myself. It's OK. It hasn't lost any weight, but the relentless advance of computer technology means that it's no biggie any more.

Firefox is now under some threat from Google Chrome (one of whose developers being a certain Ben Goodger). Chrome is based on Apple's Webkit but with a better UI than Safari (a project headed, amongst others, by one Dave Hyatt). Webkit is Apple's cleaned-up, enhanced version of KDE's KHTML rendering library from the Konqueror browser. Webkit is so much better that KDE have given up on KHTML and now use Webkit too.

Now there are basically four main families of browser:

Internet Explorer. Windows-only nowadays, but to most people, IE is The Internet. IE6 sucks bigtime, but tons of big companies are wedded to it, so it shambles on, undead. I suppose that makes it a sort of zombie used by dinosaurs, which actually sounds kind of cool. IE 7 and 8 are sort of OK, if you're the sort of person who doesn't mind sharing needles with strangers.

Mozilla, AKA Firefox, Seamonkey, Camino and loads of others.

Both, ironically, while being lifelong bitter rivals, are descended from Mosaic.

Then there's Webkit, AKA KHTML, AKA Chrome, Safari, Konqueror, the Nokia Symbian browser and others. It was developed from scratch in the late 1990s.

And Opera, doing its own idiosyncratic thing for seventeen years. "MultiTorg" coexisted with Mosaic back when giants walked the Earth.

It's been 20 years now since the GNU microkernel Unix, the HURD, was announced. So where is it?

Bear in mind in the following that when I speak of an OS I am talking about the core OS - the kernel and essential services. Not the shell or the filesystem or user tools like ``ls'' or ``more'' or ``vi'' or anything, and certainly nothing to do with relatively trivial outer layers such as graphical user interfaces.

The GNU HURD was a very ambitious project: to build a complete, UNIX-compatible OS on a microkernel basis. Microkernels ("µkernel" for short) are very hard to make work, but it has been done - QNX, Chorus, Amoeba and others are all technically microkernels, for instance. Not are really Unices, though, although QNX sort of superficially resembles one enough for developers to feel some familiarity.

Contrary to popular belief and Apple & NeXT's strongly-promoted message, neither Mac OS X nor NeXTstep before it were technically microkernels.

The idea of a microkernel is that only a tiny piece of code runs in the processor's (or processors') Ring 0; the rest of the OS is composed of small pieces of userspace code, running in Ring 2 or 3 (using x86-32 rings for reference here). The modules, called servers or daemons, all communicate with each other to work together as a complete OS.

The theory is that because the OS is very modular, it is easier to work on, more reliable and more robust. If a server dies, it can be restarted and the rest of the kernel will not be affected.

The first microkernel to get much real-world recognition was Mach, designed at Carnegie-Mellon University in the USA. Mach didn't get to a reasonable level of completion until Mach 3.0 but the earlier versions spawned a host of projects.

One was OSF/1 by Digital Equipment Corporation, which became Compaq Tru64 and was killed by HP. Another was MkLinux for the original Motorola 680x0-based Apple Macintoshes.

And one was NeXTstep, which became Mac OS X.

To make their new OS viable, NeXT wanted to make something Unix-compatible, so they took a huge chunk of the kernel of BSD (not FreeBSD or NetBSD or OpenBSD, this is before them) and built it directly into the Mach kernel as a sort of "Unix compatibility later". This means that the kernel is no longer "micro" at all - it has a honking great monolithic lump of old Unix code bolted onto it.

The result is called Xnu, and whereas it may not be the most elegant solution, it certainly works. It's now the best-selling Unix ever, estimated to outnumber, in both installed systems and number of users, every other commercial Unix and Unix clone put together.

GNU took the Mach kernel as well as the basis for HURD, but it tried to do things properly, the pure microkernel way. When Linus Torvalds wrote his kernel, he didn't expect it to compete with HURD - it was meant to be a small quick hack. As he famously said in news:comp.os.minix: "I'm doing a (free) operating system (just a
hobby, won't be big and professional like gnu) for 386(486) AT clones."

That was the first announcement of what became and was later named Linux. (It had been called "Freax".)

The thing is, the GNU developers found that writing a microkernel-based Unix is very very very hard.

When Linus made his post, Prof. Andy Tanenbaum, a very respected academic in OS research and the author of Minix, the OS that begat Linux, said Linux was obsolete: the direction of the future was clearly microkernels. (And indeed Tanenbaum has produced several µkernel OSs himself.)

Technically, at least in a theoretical sense, he was right, but Torvalds' practicality in deciding to implement a simple, classical, one-big-monolithic-lump-of-code type of old-fashioned Unix kernel has been proved correct - Linux is now mature, sophisticated and highly usable. In some terms, proprietary Unixes such as HP/UX or AIX or Solaris might do some things better, but Linux is doing very well.

Meantime, 20y later, the GNU team have not made all that much progress with HURD.

About 4y ago, it has got to a stage where it looked like it could be used for simple stuff. Debian built a version of the Debian GNU distro around the new HURD kernel instead of the Linux kernel. (There are also Debians built around all the BSD kernels.)

An announcement was made on Slashdot. The infant OS was hosting its own website. It immediately collapsed under the onslaught.

Soon after this, the team decided that things had moved on since the creation of Mach in the early 1980s and moved HURD onto a new, more sophisticated and mature µkernel: L4. This involved a very big backward step, so arguably, HURD is less complete and ready now than it was then. Also, things have moved on since L4 and it too has successors, and research projects are looking at them as possible HURD bases, too.

Personally, I think that one day, Linux is just going to prove to be too big and too complex to maintain and develop efficiently any more. Some developers might move on to a successor, something more modular. I'd have liked to see kernel 2.6 named 3.0 when it was released - there was no planned 2.8 or work-in-progress 2.7; indeed the old stable-and-development-kernels-in-tandem model has been discarded.

But perhaps some day a modular Linux 3.0 might be started.

There are other directions - for instance, the chaps that originally developed Unix (of which Linux is really just a re-implementation) went on to further refine and develop their ideas in Plan 9, which later developed into Inferno. These are networked OSs, with resource sharing between nodes an integral OS concept, rather than something bolted on later as it is with Linux, Unix, Windows and so on.

I do not understand the technical details but the structure of Plan 9 apparently makes the whole concept of µkernels irrelevant - it is functionally divided into pieces already, just not alone the same division of privileged tiny kernel + user-space servers as µkernel OSs. I'd like to see development on Plan 9 picked up and the enhancements of modern Unixes, such as Linux, brought to it. That could be something very special.

Also, given that other µkernel research OSs have made it to complete, functional condition, such as Minix 3, then perhaps the HURD design is flawed and they should drop it and move on to HURD 2 or something. I don't know enough about the minutiæ.

But HURD isn't finished, maybe never well be, but it's been a very interesting project all the same. And whereas maybe µkernels are not the right way to go, I think the evidence from Minix 3 and Ameoba and QNX and so on is that they can be made to work, and perhaps that is how things will in fact go one day.

Those who don't read Twitter or Facebook may be unaware of the series on Linux I've done for The Register this week (amongst other stuff).

So here are some links...

http://www.theregister.co.uk/2010/06/21/reg_linux_guide_1/

http://www.theregister.co.uk/2010/06/23/reg_linux_guide_2/

http://www.theregister.co.uk/2010/06/24/reg_linux_guide_3/