So Tao was my first startup. And then it was my first that-awkward-stage-when-you're-too-old-to-be-a-startup-but-still-don't-have-proper-cashflow. Then it laid off 50% of the staff, then it went bankrupt, then it came back from the dead, then it went bankrupt again.
The lessons I learnt from Tao were:
1. Your company needs to be called something which people can pronounce. ('Where do you work?' 'Tao.' 'Dell?' 'Er... no.')
2. An OS which requires people to code for it in a language which only exists in-house is not going to get much external traction.
3. People don't buy advanced technology and then figure out what to do with it. They figure out what they want to do and then buy the technology.
4. When the paycheques stop showing up, leave.
The technology was great. I joined just as TAOS was being migrated to intent. Both worked in the same sort of way; code was written in a custom portable assembly language, which was then translated into native machine code when it was loaded into the machine. The TAOS language was VP1, the intent one was VP2, and the first VP2 systems were hosted on TAOS, so it actually translated VP2 into VP1 and then into native. Translation was very, very fast; as both VP were pretty dense it was possible to load and translate VP faster than loading native code, on certain combinations of platforms.
VP1 had 16 registers and a pretty simple instruction set. The original incarnation was a assembler macro package. VP2 was way more complicated. It had five register banks (int32, int64, pointer, float, double) of up to 65535 registers each. It was actually a pretty nice system to program in, especially when the assembler got strong typing and structured programming support... yeah, I know what you're thinking.
The OS itself was way ahead of its time: it was an asymmetric multiprocessor system, where you could have any number of nodes of different CPU types hooked together via a message-passing system. Code loading was transparent, and devices and filesystems could be attached to any node on the system. It had a blisteringly fast compositing GUI, cutting edge audio synthesis, hardware accelerated OpenGL, and eventually ran on, deep breath: 386 x86 ARM MIPS PowerPC MCore ColdFire Transputer ShBoom and a V, um, V840? Or something?
Our standard development procedure for new hardware was to have intent running (inside a Linux process) on a desktop PC; we'd bootstrap a development board up to the point of having serial support and the VP loader; then we'd hook them together. Suddenly, we have a two-node system. We could start a terminal on the desktop and see that node #0 was a Pentium and node #1 was, say, a ColdFire. You could then spawn a process on node #1 and it would run transparently on the dev board with full access to the desktop's filesystem and device drivers, all running, quite slowly, over the serial link.
We had a TAOS-era demo box which was a 9-node system consisting of an elderly Pentium and eight transputer nodes; one of the demos was to draw a Mandelbrot, farming each scanline out to a different node. Alas, by the time the transputers had finished drawing their scanline, the Pentium had drawn the entire rest of the image...
We never, ever sold the multicore system to anyone. Back in those days it was too novel for customers to know what to do with. Instead we sold it as a embedded OS, which it did really well at. We had a JVM for it, which translated Java bytecodes into VP2, which meant we got, pretty much for free, a Java JIT to native machine code which didn't require any additional porting; any system intent supported also supported Java. (See that list of architectures above? We had a Java JIT that targeted the frickin' TRANSPUTER.) For a while we were the de-facto standard Windows Mobile JVM. Even now there are still copies floating around.
But you can't make money selling JVMs; the Sun licensing fees and the large team required for conformance testing soak up any margins. We were asked whether we wanted to become the standard Blu-Ray JVM. We said no --- we didn't see how we could make any money at it. In hindsight that was probably a bad idea, because if we'd said yes then maybe someone would have cared about the company surviving.
C and C++ was supported, eventually; we had a gcc port which produced VP2. This was back in the gcc 2.95 days. I'm not sure you realise how horrible gcc 2.95 was, but it was very horrible. C wasn't a good match to the intent way of doing things and we didn't put as much effort into it than we should have; eventually we got traditional programming models complete with shared libraries and dlopen() but it was way too late to matter. Even right at the very end the vast bulk of the system was written in VP2 assembly.
We had a fling with Amiga pretty late on, and were the technology behind Amiga Anywhere, which nobody ever cared about. (Although we did actually get a few external users. The sheer novelty of this was hard to handle.)
If you actually want to get your hands on an intent development kit, there are some legal copies floating around: we bankrolled a short-lived 'magazine' (read, advertisement) called Digital Magazine, and one issue had a complete PC dev kit on the cover CD. Here's the advert, and yes, the cover picture horribly embarrassed us: http://www.amigahistory.plus.com/amiga_active/digital4press.... But I don't know if there's a copy online. (If you find one, let me know!) You may find this OSNews post about it amusing; drink every time you see a commentor say 'But what is it?'. http://www.osnews.com/comments/743
Eventually the company ran out of money for the last time and completely went under. I regret it deeply; the people were amazing and very, very smart, and the technology was deeply cool. Back in the 90s we worked with Motorola to produce a modern-style touchscreen smartphone; the software stack was in Java, running on an 11MHz ARM. It was fast and responsive and would run full-screen games. Did I mention it ran on an 11MHz ARM? IT RAN ON AN 11MHz ARM. But Motorola canned it shortly before launch. If they'd actually launched it, then Tao, and the entire smartphone world, would be very different.
Our CEO said that his ambition was for Tao to be bigger than Acorn. Well, he got his wish when Acorn folded shortly before we did. Sigh.
I have an actual program for intent. It's crap, but: http://cowlark.com/foo-fighter/index.html
It's in C, unfortunately, so there's nothing there of very much technological interest, but you can look at the APIs and marvel at my 13-year old code. I appear to have left a compiled binary with debugging information in it. It may even run on the Amiga Anywhere runtime or the intent ADK, if you can find one.
Update: Here's a screenshot of an editor with some VP2 assembly in it: http://mobile.osnews.com/img/vp.jpg
This is part of a program which displays images on the GUI. It's VP2 using partially-typed assembly (we went through several iterations). 'tool' defines a loadable module. qcall calls another loadable module, which is loaded dynamically or statically depending on flags. ncall makes a method call on an object (using a blisteringly fast hash table lookup, so you get dynamic method resolution in about four instructions). Calls can have multiple inputs and multiple outputs; registers are saved for you automatically. gp is a special register pointing at the app's globals.
Update update: And here's the GUI in action (it was called the AVE). http://mobile.osnews.com/img/quake.jpg It's running hosted on Windows. It's all composited --- note the transparent windows (unheard of in those days)! The viewflm window in the background is running an animation, which you can see through the transparent overlays while two Quake games run.
This is all done in software, using simple but very, very careful code written by Chris Hinsley. It was amazingly fast.
Maybe I'm crazy, but this level of abstraction is somehow to my taste, and it looks like Tao would be fun to program in. Shame that it didn't make any impact. Had it been open sourced in 1998, things might had been quite different...
What happened to the Amiga deal? You alluded to it in another post. That sounds like another really interesting story.
I don't know why it failed; we didn't have anything to do with Amiga's operations, apart from offering support. (I don't think any of us were Amiga people.) My impression was that the general feeling inside Tao was that the Amiga of the time was cursed, and we didn't want anything to do with it. Tao itself wasn't doing well then and we were all a bit superstitious. It didn't help that the main person we dealt with was called Fleecy Moss.
I did get one perk out of it: I own a copy of the Amiga comeback album. Lucky me. https://www.youtube.com/watch?v=szMGxqwfxiI
Here's a terrible video of someone from Amiga demoing it. God, those iPaqs. I had one on my desk with a PCMCIA hard drive in it for doing the ARM Linux port. Horrible, horrible things. https://www.youtube.com/watch?v=HfHcwpzxSdk
I'd be interested in playing with a copy of AA if I could get my hands on a version which would run on a modern machine.
At the time, the Amiga name didn't have a lot of mainstream recognition anymore. And the people who still cared about Amiga slammed AA every chance they got on amiga.org & amigaworld.net because it wasn't classic AmigaOS running on a cell phone. There was a lot of resentment that the Amiga name & logos were being slapped on something completely unrelated.
Open sourcing it's probably not useful: it was based almost entirely on tribal knowledge, passed from developer to developer, and learning curve was pretty steep. I worked on our translator for a while, porting it to new CPU backends, and... yuck.
However, please try; somewhere in that lawyer's basement is a short story which I wrote in my lunch break, emailed to a friend, shortly before the company went bust... and I forgot to send a copy to my personal account. And my friend lost it. I want that back, dammit.
How large was the core Taos kernel and basic userland? What kind of effort do you estimate would be needed to bootstrap a libre clone? Have any people ever considered doing this before?
Elate/intent was way, way bigger. It was a proper filesystem, with device drivers (object-oriented and named and mounted in the VFS), and modules and components and a package manager (which was actually pretty awesome) and Posix and a huge standard library. Even the translator was big, by which I mean double-digit kilobytes of translated code.
I would say it's not worth cloning. State of the art in JITs has moved on so much that intent's fairly crude binary translation's not worth much. Instead I'd use something like LuaJIT as a JIT core, and build up from there; it's fast, tiny by modern standards (although still way bigger than the intent core), and you get binary portability by pushing Lua bytecode around instead. Compiling C into FFI-heavy LuaJIT shouldn't be too terrible and should give decent performance, while keeping portability.
Incidentally, despite my previous message, it may be possible that Amiga Anywhere still has an intent license. Which means they might have source code (because it's not like they're going to get builds from Tao any more). Does anyone know if Amiga Anywhere is still a thing?
Ah, here it is:
Mmm. I don't remember it being quite that brick-like.
And yep, the history of Smartphones would have been very different if Moto had shipped it !
The history of Java would have been different too, because this was before all the K-Java stuff that was a response to getting Java into smaller footprints !
The company was called Tao, which nobody could pronounce.
The first OS was TAOS.
The second OS, which succeeded it, was Elate. Except, when Elate was running hosted on another OS, it was called int<b>e</b>nt. Yes, the bold e was part of the name. Except, when Amiga had it, it was called Amiga Anywhere.
Most comments of the era run along the lines of 'but what the hell is this?'. And for good reason.
I heard about the name change to "Elate" second hand. "taos" had to change to "elate" everywhere -- even the options.
The naming may or may not have sucked, but it definitely did blow having to tell the compiler to "-felate-tool".
Pronouncing skills (the absent of) of native English speakers constantly surprises me. But this case goes to absurd levels...
A photo of a package for Acorn Archimedes refers to a 'developer edition'. Archimedes computers could host transputers.
Right at the bottom - labelled as 'never released'
Looks like Acorn were considering TAOS OS just before retiring from the general computer business.
EDIT: A later development after they went into embedded with some kind of java based runtime
According to Wikipedia the company was sold in 2007 (https://en.wikipedia.org/wiki/Tao_Group). That's a pretty long run from the early 90s.
I've tried emailing Chris Hinsley to see if he wants to answer questions on HN. An old email address, but maybe he'll see it at some point.
The wiki article lists quite a convoluted history, not to mention all the rebrandings. It seems like they never really focused on attracting researchers or considering any FOSS presence, which is a shame because it's now practically lost by this point.
If Hinsley answers, that'd be great.
(a) was obviously dumb, but (b) had a point. We would have gotten people asking us questions. With a tiny staff we'd have had to blow off anyone who weren't paying for a support contract, which would have gotten us bad press; and given how weird intent was, we would have got questions. Part of the reason for the Amiga deal was that they'd do this for us. Well, that went well...
With hindsight Tao should have done this.
This sounds like a massive case of post hoc ergo propter hoc.
Prior to the rise of the GPL and other formal F/OSS licensing models, there was some explicitly-dedicated-to-the-public-domain software, and lots of lax enforcement of copyrights in software, and, especially prior to 1974, some doubt about the copyright status of software. Before automatic copyright in 1978, and especially before 1974, lots of software was probably not copyrighted (because it took an active step to do so and because there was doubt about whether doing so would have any legal effect.)
But I don't think open source was ever the norm for software once it was clear that copyright protection was available, and certainly not once it became automatic.
However I did start an experimental project a while back to do a simple Taos like kernel over BSD/Linux in x86_64, VP macros and process load balancing, point to point link network simulation and function level dynamic binding ?
Look for the Asm-Kernel project amongst my other stuff.
Was just starting to work on a GUI, AVE MK 6 :) But then got into a new job and it's currently sat at that stage till I go back to it.
Regards to all, was great to read this and bring back such wonderful memories of the great team we had at Tao, some of the brightest tech people I have ever had the pleasure to learn from.
Would love to see it (what's left of it!) open sourced.
> TAOS stores objects onto mass storage media like hard disks via the mailbox
system, in objects called 'filefolders'. A filefolder has some similarities to
a DOS or Unix directory, but rather than being a passive storage structure it
is an active object (in fact a control object). The tools attached to every
filefolder are responsible for storing and retrieving objects from the folder
and for negotiating with the hardware device drivers that are necessary for
this transfer. Because filefolders are actually instances of a broader category
of TAOS object called 'filters' they may also process the data they transfer,
for example compressing and expanding it transparently to the user.
Emphasis added. Oh, it seems they were so close here. The biggest central problem with Unix mount, apart from synchonous/trusted I/O, is that the things that are exposed to the OS through mounting are only files, and never processes ...
With plan9port https://swtch.com/plan9port/ you can mount processes on any UNIX.
Its probably my age and not keeping up with the research, but it feels like there were more diversity and cool things going on in OS reserach and R&D back then.
Though the development of VMs and OSes for IoT and mobile devices is probably a good counterpoint.
Then again, I'm one of the few who actually bought a copy of BeOS. RIP, isComputerOn/isComputerOnFire...
"Inmos T800 transputer, Motorola 680x0, PgC7600 (see article in this issue), Intel 80386/80486, Acorn ARM and Sun SPARC"
Of these x86 and ARM dominates the world today.
Meanwhile Linux has always been a boring SysV Unix clone that only occasionally ripped some features (and in a questionable manner) like procfs, sysfs, epoll, signalfd so you don't have to do the self-pipe trick, inotify, cgroups and namespaces. Stuff that competing systems often did much better.
The BSDs have been quicker to do more novel things, but by far the only two modern Unices to get the memo are DragonFly BSD and Solaris/illumos.
I wonder how long it will be before the turtle pokes its head out?
I was waxing lyrical at the Plan9 conference to Richard who I have known for a few years about how amazing the turtle and Logo is/was for classrooms because it could engage with a wider range of children than trying to teach them programming because it stimulated those maybe interested in programming, art, robotics, languages and maths with teamwork and communication skills and even just watching things happening. Imagine my pleasure when he said "I'm glad you appreciate it" and went on to tell me the story of developing it when I had no idea!
Edit: wow, he's everywhere.
It's a secure microkernelly capability-based OS where each process is basically a virtualised hypervisor; it can run a conventional OS as a user process, but it's also got a Unix-like native personality if you want it. I believe it's nearly self-hosting.
I personally would love to have a modern Lisp machine. Alas, having lived through the 90's, I'm glad that we at least have Unix. Perhaps someday everything will be unikernels.
The bastard child of CP/M...
Grand Abstractions are cool and powerful when you are happy to live within their universe. But they tend to be incompatible with other Grand Abstractions.
That's why modern kernels tend to focus on Boring Abstractions (threads, processes, locks, memory maps, files, cgroups, etc.) Then the interesting and more opinionated stuff can happen in user-space (Docker, JIT-comiling VMs, web browsers, mobile apps, etc)
Change the way you think about code, and change the world. And it starts with the application environment, often called the OS.
Ask yourself this: could you efficiently implement Taos abstractions on top of POSIX? (probably yes) Could you efficiently implement POSIX abstractions on top of Taos? (probably no) That is the difference between a Grand Abstraction and a Boring Abstraction.
> Change the way you think about code, and change the world.
I agree that Grand Abstractions can be powerful.
> And it starts with the application environment, often called the OS.
Sure, just leave the GAs out of the kernel. It doesn't mean you can't have them. Just put them in user-space. Then GAs can operate in a competitive market where you use them because you want to, not because you have to.
All of those should properly be managed by a kernel, yes?
Sort of like Erlang? Which can run on POSIX.
> Perhaps instead of processes we'd use just virtual machines.
Sort of like the JVM, or Docker, or VirtualBox, or any number of VM technologies that run on POSIX?
> There are strong reasons to want safety and security guarantees around the lifetimes of those things.
Why do any of these things need to live in the kernel to give safety/security guarantees? If anything, code that runs in the kernel is more vulnerable, not less.
btw. I don't think POSIX is the be-all end-all or anything. But if I imagine something better than POSIX, its abstractions are even less opinionated than POSIX, not more.
I only care about OS POSIX support every time I have to go down to C or C++. Otherwise the OS can have whatever abstraction model it feels like.
We are currently stuck with VMS influenced OS and UNIX clones everywhere.
This is why I follow the MacOS X, Android and WinRT changes as their stacks could completely replace the old idioms if they didn't care about backwards compatibility.
Watch it, it's short, funny, and food for thought: http://worrydream.com/dbx/
In general, a small number of reposts is ok if an article hasn't had significant attention in the last year or so . Letting good stories have a few cracks at making the front page helps mitigate the randomness of what gets traction here.
1. Please see https://news.ycombinator.com/newsfaq.html.
Looks like "taos os" was the thing to search on: https://hn.algolia.com/?query=taos%20os&sort=byDate&prefix&p....