Commentee comment - could the author miss the point any more widely?
"The culture of computing for several decades has been C and Unix or Unix-like OSes"
Off-hand, I can think of a lot of operating systems which haven't fallen into these categories. The Japanese Tron OS, BeOS, RiscOS, Amiga OS, QNX, Warp, VMS, MS-DOS, Palm OS, etc. Some may have been written in C and some may have been a bit *nixy, but not at the same time.
They just haven't caught on in the same way as *nix systems. To me, a big part of the reason for this is that Unix came from a mainframe/multi-user/batch-processing background, and therefore had a head start when it came to modern "networked server" paradigms (e.g. LAMP), where a given machine may be running dozens if not hundreds of tasks in parallel. And, y'know, the whole "free as in speech and occasionally beer" thing for OSs such as Linux and BSD; combined with the dropping cost of hardware, this led to a huge takeup of *nix systems by amateur enthusiasts, which then fed back into the workplace.
Other systems - including Oberon - generally came from a consumer or real-time/single user perspective, and weren't able to adapt. Windows is a notable exception, though it's telling that Microsoft accomplished this by essentially ditching their old codebase and switching over to their multi-process/multi-user New Technology system - and which itself was built by engineers from DEC, who had previously worked on VMS, a server-orientated competitor to *nix...
"The IT industry assumes that operating systems have to be written in C to work -- wrong -- and must by nature be big and complex -- wrong."
I don't think anyone is claiming that an OS absolutely has to be written in C [barring the odd flareup of flamewars on places like Slashdot]; it's just that the most popular operating systems have been written in it.
As to whether or not an OS should be big and complex: that's a full-blown topic all by itself. Modern hardware is so much more complex than hardware from even just a decade ago, and we expect it to do far more: more data, more threads, more peripherals, more displays, higher throughputs, more parallel processes, virtualised hardware, etc - and we expect all this to happen flawlessly and reliably on low-cost, commodity hardware. Handling everything that can go wrong - from dropped network packets to processor stalls - is complex and needs lots of defensive code.
It's also worth noting that there's been many efforts to go down the micro-kernel route - QNX and Gnu Hurd being two prime examples, with the latter being a prime example of how "theoretically superior" concepts don't always come out as expected in the real world.
"But it should be something simple, clean, modern, written in a single language from the bottom of the OS stack to the top -- and that language should not be C or any relative or derivative of C, because C is old, outmoded and there are better tools: easier, safer, more powerful, more capable."
I'd love to hear suggestions on what should replace it? It sounds like you're rejecting things like Java and C# (and hence by extension things like the Android runtime)
Other than these, the last real attempt to do this was BeOS, and this failed. Partly due to allegedly dodgy behaviour from a certain industry giant, partly because they targetted the consumer market and partly because they couldn't get a critical mass of applications and developers.
"We should start over, using the lessons we have learned. We should give kids something small, fast, simple, clean, efficient. Not piles of kludge layered on top of a late-1960s hack."
Perhaps the biggest lesson to learn is that reinventing the wheel is expensive, time consuming and generally pointless. Most if not all of the technical lessons we have learned are already encapsulated in the current popular operating systems - they've survived and grown because they've evolved and rearchitected themselves along the way. Both Windows NT and Linux have moved towards "hybrid" kernel design - not quite microkernel, but not entirely monolithic. They handle a wide range of physical hardware from a vast range of manufacturers - CPUs, network/audio/network/video/etc. They handle as many real-world issues (packet drops, security attacks, parity errors, etc) as they can. There's literally thousands of man-hours which have been ploughed into making them as robust as possible.
Dismissing all of that as "hacks" is simply foolish. I'm reminded of the article by Joel Spolsky, written back when Mozilla decided to reinvent the wheel and reimplement Netscape Navigator from scratch, and in doing so essentially conceded the browser wars to Microsoft. http://www.joelonsoftware.com/articles/fog0000000069.html
"No, we should not be teaching children with "real world" tools. That is for job training. Education is not job training, and vice versa. You don't teach schoolkids woodwork with chainsaws and 100m tall trees"
Oddly, to my mind, that's exactly what you're proposed. In fact, you're essentially expecting them to first assemble the chainsaw before firing it up. And therein lies the thing which this article seems to have misunderstood; it's about fifteen years out of date. The computer as a singular device has long since stopped being the primary thing people need to learn about; these days, it's all about what you can plug into it (or what you can plug it into), whether that's a camera, a network, a mechanical device, a sensor or a coffee machine. To do this, you need a development environment and tools (e.g. an IDE and support libraries), and that's precisely what things like the Pi - and the linux ecosystem - offer.
So no, we shouldn't be pointing schoolkids at a tree and passing them the parts to a chainsaw. We should be giving them some planks of wood, a saw, some nails and a hammer and telling them to build a birdhouse based upon an existing template. Said template may have been sketched out in the sixties and look a bit crap, but it's tried and tested and the children are free to innovate and reinterpret it - maybe they can use a 3D printer to give it a tiled-roof look, or a CNC milling device to etch the face of their mum on the side...
Biting the hand that feeds IT
