Slashdot Mirror
Amiga Update: When Will The Creature Awaken?
morton2002 writes: "I read an awesome interview of Amiga head honchos by IBM's developerWorks folks. (Linked to from a cool microprocessor news site, www.jc-news.com/pc.) They discuss Amiga's new technology and marketing tactics, suitably referred to as the 'new Amiga.' Instead of developing new Amiga hardware, they're using a code-morphing virtual-machine to run on existing platforms ... but most notably it will translate their 'VP' code into native instead of interpreting it, running blindingly fast! Not only that, they'll be bringing awesome hardware acceleration to OSes like Linux when they port their VP translators to various videocard processors, allowing the 'new Amiga' to run directly on graphics-intensive hardware ... just like it used to!"
Reader Upsilon points to the same interview, saying "I have to admit, some of the stuff sounds very interesting, but it is hard not to be skeptical." (Anyone holding your breath, please raise your right hand so you can be counted before you keel over.)
I don't buy this. The Amiga was a Motorola 68k class machine with some very special chips in it. The magic of a set of talented engineers for whom it was the next challenge after the equally amazing Atari 8 bit series. It was not some grand vision or quest, and it certainly isn't the hardly revolutionary idea of having architecture-independant binaries. Their software doesn't become any more interesting just because they happen to be sitting on the trademark. Might as well say that Amiga was always really about household appliances and start a line of that.
"This is one thing people don't understand, and they keep on saying, "The new Amiga provides portable binaries. Portable binaries are slow." Now, in the past they've been slow because portable binaries have always been interpreted. But what happens with Tao's Intent is that they are dynamically translated into actual native machine code. It only has to be translated from VP code to native code once.
Er, correct me if I'm wrong, but I believe this is popularly referred to as "Just In Time Compilation". Dude, it's been done, and yes, it's still slow. There is no such thing as a magic compiler. Hand-tuned assembly is faster than compiled source code, and compiled source code is faster than translated machine code. This shouldn't be that surprising. At each lower level, you have more context in which to make optimizations. Automatic translation of machine code has almost no high-level context.
See also the x86 emulators on the Mac. They use the same principles. They are slow.
These are the kind of things that make me think this is all smoke and mirrors.
--
Sometimes it's best to just let stupid people be stupid.
While past Amiga stories have been, um, bizarre, there's something to this one that shows at least someone is on the right track. It may have nothing to do with the original Amiga, but it is a good track nonetheless.
The Amiga and other home computers from earlier years were about predictability and overall system design. An Amiga--or an Atari 800--wasn't about being the best in terms of CPU power or OS capabilities or raw graphics performance. Those machines were designed from the start to be balanced systems. Each subsystem was clean and well-integrated into the rest of the machine, without being an obvious bottleneck or weak link. On a typical PC, you might have a blazing CPU and a blazing graphics card, but you have a horrible bus between the two. And you have mishmoshes of horrible APIs that frustrate more than they assist.
Predictability was a great feature of old machines that has been lost. When you do something as simple as read a memory location on a modern PC, you aren't sure what's going to happen. You might hit the on-chip cache. You might hit a slower layer of cache. You might have to wait for a cache line to be filled from RAM. You might hit untouched virtual memory and have the OS intervene. You might have to wait a really long time while the OS pages some memory out to disk to make room for the memory you need. When you make an OpenGL call to draw a triangle, you're never sure if your request is simply going to be queued, if it is going to result in 200 previously queued requests being processed because a buffer has been filled, if you're using states that will take you down an unoptimized driver path, etc. Layers of unpredictability like this have always been the difference between heavy iron and smaller machines.
What the Amiga folks seem to be doing is trying to hide all the nonsense from the developer, letting him live in a fantasy world where everything is clean and pretty. If that prettiness is at the right level--that is, in terms of very small, understandable chunks and not highly abstract and complex system calls--then there's much peace of mind to be gained by living in such a world. After all, most programmers choose to live in the world provided by C++ and Windows or Linux APIs and libraries. That's a virtual world too, but it comes with a lot more niggling details and mental baggage than what we're talking about here, and not making any significant use of the available capabilities as a result. One of the great unfortunate truths about current PC hardware, is that is it is being tremendously under utilized.
Yes, we're still looking at some form of emulation here, but that's not a bad thing. The old Apple II let the programmer feel like he was the master of the machine, something that is rarely felt nowadays. If you decided to do Apple II development in 2000, you could get an emulator running under an OS, and you'd get the same feeling. You'd be emulated, but you wouldn't care. You'd be dealing with a much smaller world, and you'd feel less technical stress. I see the Amiga plan as being similar to this, but based on more recent hardware capabilities. It might provide a much needed focus for developers, rather than wading around in ever-changing this and that. One of the great unspoken truths is that modern PC hardware is tremendously under utilized. Lack of focus is the primary reason for this.
Ars Technica posted this as well. Hannibal had an interesting comment: So they're not requiring that all AmigaOS software and tools be written to the virtual processor, which is interesting because this at first seemed to me to be a sort of fence sitting approach that would reduce the advantages of translation -- why not just go ahead and use an OS that's completely portable at the source code level, like Linux? When I thought about, though, I realized that what Amiga wants is to release an OS in binary form that runs on a variety of platforms from the start, and have people start moving pieces of the OS into native binary form for their specific platform as they see fit. This would be the opposite of a Linux-style approach, where you initially release an OS in source code form that runs on one platform, and then let people port the entire thing to their individual hardware.
"The legitimate powers of government extend only to such acts as are injurious to others." Thomas Jefferson.