Tao release Free intent ADK with Digital Magazine

Mike Bouma writes: "A special release of the intent Application Development Kit for Windows and Linux is included on the cover CD of the current issue of digital magazine. Intent is the core technology used in the AmigaDE and is also the standard programming and the platform independent content environment chosen by the Open Contents Platform Association (OCPA) for digital consumer devices. Consumer Electronic Giants including Hitachi, Sony, Kyocera, PSION, Nokia, NEC, Motorola, Grundig, JVC, Fujitsu, Sharp, Epson, Intel, Pioneer, Metrowerks, Sega, Bandai and Capcom are supporting the platform. A full new release of the AmigaDE Software Development Kit will become available for general developers later this year. Software developed for intent works with the AmigaDE platform as well. Recently a partnership between Amiga and Nokia was revealed and finally here are some links to recent interviews with AmigaDE software developers."

Amiga

[Anonymous Coward]

The Amiga/TAO environment is pretty damn cool, easily the best software VM architecture out there, and is basically what .net and Java should be, but aren't.

It's NOT a forth-inspired stack based architecture like .net and Java, but rather works with an "unbounded register set", which is a wierd, but definitely cool way of doing things.

Sure, on any given processor architecture, for enough registers, it must eventually devolve into stack/main memory access, but the VM takes care of the best mapping for you. Thus, it can take full advantage of modern RISC architectures.

It's not currently fully open source (more source-available-proprietary), but they strongly support the GPL software community, and intend to continue doing so in future.

Open sourcers actually interested in best-of-breed systems should be cloning Tao, not .net and Java.

Does any one remember the AMD 29000?

[Max Hyre]

Now there was a chip the TAO VM could scream on. It [sympatico.ca] had 128 (!) registers (real, on-chip, full-speed, directly-addressable registers), of which 64 were local, organized as a circular queue, but accessed as the top of stack. Sounds like pretty close to an ``unbounded register set'' to me.

<reminisce mode>

Want to call a function? Stash your arguments in registers, and bang!, you're there. Of course, when you got to the edges (few used, or most used), you had to ``fill'' or ``spill'' from RAM (or cache), but it was all but invisible to the programmer. They had separate instruction and data memory (``Harvard'' architecture), so you could access both simultaneously.

IMHO as a programmer (not architect), the only shortcoming was their condition-code setup. There was no CC register---you did a comparison, and stashed the result in whatever register was handy, branching later on testing that reg. true or false. They missed a bet---they should have stashed a full set of conditions in the register, so you could compare once, then test as many conditions as your little heart desired, instead of: compare LT, jp T, compare EQ, jp F, ..., do: compare, jp LT, jp EQ, .... Ah, well...

AMD introduced it as a general-computing chip, for high-end Unix boxes, workstations, &c. Unfortunately, they did it just as the IBM PC juggernaut was coming up to speed, and the x86 flood swept it away. AMD tried to convert it into an embedded-system chip (which is where I met it), but like so many others (88000 [Honeywell?], 32000 [National?]), they faded away. AMD officially dropped support for it a few years ago. Damn, that was one sweet chip.

(Of course, the Harvard architecture was fit to give HW engineers apoplexy, but that wasn't my problem. :-) If this interests you, just do a Google search on "AMD 29000". I'm not the only one still carrying the torch for it. So many of those 32-bit efforts were funcionally superior to what's left today.

</reminisce mode>

huh?

[muchandr]

I don't see how the 29000 is any special, in particular relating to Tao. It seems to be a rather generic chip, quite a me-too effort from
AMD. Not that it was bad, but let's see:

Unbounded register set' is most commonly achieved by register renaming these days. SPARC-style sliding 'register windows' are generally agreed to have been a mistake due to implementation complexity (note how SPARC has always been behind on Mhz to competing RISC designs (as long as those still existed) Lots of registers are good, but don't forget that 128 of them takes up 8 bits
of space per-register from the opcode. The first (almost) orthogonal register set I am aware of is the one of M68K, which was quite CISC. Harvard architecture takes away the option of writing self-modifying code, which can be quite powerful. Every chip since 68020 is Harvard, so the point is moot anyway. I totally agree on CCs - the architectures than left them out (MIPS was first) lost a lot more than the miniscule gains in implementation complexity. Not only should you have CCs, but also predication (ala ARM and now Merced), IMHO. I think the best-ever RISC architecture was ARM, followed by PowerPC, but in
general, I find the concept of a 'register' a bit offensive. Come to think of it, a 'register' is
just memory with addressing restrictions and is just a performance hack. My ideal architecture would be some kind of a vector IRAM (say Playstation 2?), I guess.

Lots of registers

When stack machine is better than RISC

[muchandr]

This URL: http://www-2.cs.cmu.edu/~koopman/stack_computers/c ontents.html [cmu.edu] Contains a cool book on stack machines. Check it out before you slam them. Having said that, there is no good reason for the JVM to be stack- rather than register based. I think the best way to have a portable runtime were to leave the code at the stage of an AST and let every VM implementer to compile to what they want (including native) Tao 'portable assembly' thingie is way kewl and has been around for a while, too. (from since way before Java, etc.)

AmigaOS 4.0 coming...

[Snowfox]

AmigaOS 4.0 is coming. While I doubt the Amiga could ever even begin to approach mainstream use, the pure PPC/G3/G4 target, OpenGL, and other mature OS features which 4.0 will bring to the table make it quite viable again. It's even fair to say it's a step up on BeOS.

I wonder if we could make enough noise to get an amiga.slashdot.org, with boing ball, nifty color scheme, and all Amiga articles front-paged, much as the apple.slashdot.org [slashdot.org] have.

ADK license lets you sell your software!

[DamienMcKenna]

The license that comes with the ADK CD allows you to sell your software (to people who run the Intent VM), ie create an app using it and all the millions of cell phones and/or set-top-boxes that use Tao Intent will be able to run it! I did not see any mention of royalties in the comments from the Tao employee on http://ann.lu/ [ann.lu], so there may not be any.

Things to remember...

[DamienMcKenna]

This is Tao's Intent dev kit, it has nothing to do with Amiga beyond Amiga base their product on this. In fact Tao are working on their own APIs for all the things Amiga are doing, because Amiga have taken so long to get their act (and products) together. Releasing a free dev kit has allowed Tao to capture the market Amiga could not, and they are in effect killing Amiga's market.

Comments on OSNews

[Anonymous Coward]

You can find some interesting comments regarding the Tao ADK and AmigaDE here [osnews.com] on OSNews.

When stack machine RISC

[muchandr]

This URL: http://www-2.cs.cmu.edu/~koopman/stack_computers/c ontents.html [cmu.edu]Contains a cool book on stack machines. Check it out before you slam them. Having said that, there is no good reason for the JVM to be stack- rather than register based. I think the best way to have a portable runtime were to leave the code at the stage of an AST and let every VM implementer to compile to what they want (including native) Tao 'portable assembly' thingie is way kewl and has been around for a while, too. (from since way before Java, etc.)