This is the alternative second edition of the guide to the tornado operating
system. It attempts to cover most facets of tornado from an average users
perspective, while being still detailed enough for a programmer to not find
it boring :-).
For the uninitiated, the tornado operating system runs under another
operating system, RISC-OS. This operating system comes with the range of
computers running on the Arm series of CPU's made since the Acorn A3000.
Older machines using the Arm CPU can also run RISC-OS, so long as the
propriatary hardware (MEMC1a, VIDC etc) is also available and is arranged
similarly to the archimedes series - also, any hardware compatible with the
original archimedes design should have no problems.
Problems with RISC-OS:
----------------------
While RISC-OS was originally constructed during the late eighties, it still
compares quite well to the latest operating systems from Microsoft, IBM and
Apple. However, it's age does show in many areas, and the only reason why it
can still be considered alongside other operating systems is because of
original design strengths in the original release.
Advantages of RISC-OS over other operating systems:
* Extensive drag & drop facilities. RISC-OS allows dragging and dropping
from almost everywhere to everywhere else on the screen. This increases
intuitivity incredibly, but *only* when it's used to its full effect. Often
it isn't.
* The ability of a program to assume complete control of the processor. In
multitasking operating systems, RISC-OS assumes the dubious status as the
only one to use non-preemptive multitasking. The great advantage of this is
the ability for a program to hog the processor and use all its power.
* No application has control or precedence over others. This means you can
select a group of objects in a window belonging to another program currently
behind windows belonging to yet another program. While that might sound
complicated, System 7 shows how irritating not having this can be. You can be
working on something, and want to copy a file. Selecting a file in the
Finders window behind the main window brings all the Finders windows to the
front and now you can't see the main work window anymore.
A similar problem exists will Windows 95 - except that each filer window
is its own task, so clicking in it only brings one window to the foreground.
But still it shows that the application that the user is working with has
precedence over any others.
This also shows in dragging and dropping. In RISC-OS you can drag a file
out of one program into another. No other operating system allows *that* type
of flexibility and power.
Advantages of other operating systems over RISC-OS:
* Multitasking on other systems is far more fluid and consistant. On
RISC-OS, multitasking seems a very 'bodged' affair indeed - things like
printing, or even disc i/o don't multitask [1]. If you get programs to do a
lot of processing, RISC-OS slows down incredibly. Multitasking on a heavily
loaded RISC-OS desktop is like watching a demo run at 12fps.
* All tasks on RISC-OS are equal. This means that as far as RISC-OS is
concerned all tasks get equal processor time, and no task may get more than
another. This prevents an important process from getting more time so that
it gets completed quicker.
* Tasks on RISC-OS take as much processor time as they want. There is
nothing to stop them giving up control every second. If every task on RISC-OS
did that, RISC-OS quickly becomes unusable.
On other systems, a central multitasker handles how much time each task
gets. This allows the multitasker to give less or more time to each task
depending on circumstances.
* Writing programs to run under RISC-OS is a real chore. While the
interface to the desktop is very flexible, it is also very manual, with each
task doing an awful lot of work for very little initial gain.
* Programs not written to multitask on RISC-OS can't be made to. In other
words, run a single-tasking program and it will hog the machine until it
decides to finish. With many programs, you can't interrupt it without having
to start it up all over again.
* Programs which crash on RISC-OS aren't handled well. Currently, when a
program tries to access memory not available to it a box appears saying at
best 'Fatal error ...' and multitasking stops until the user acknowledges
the message. On Windows 95, if a program crashes to the extent multitasking
stops, you can hit a hotkey and windows will ask you if you want to terminate
it. Or if you wait long enough, this happens automatically.
* External access isn't handled well. RISC-OS contains no standard
provisions for network access [2], and to use the serial or parallel port is
fiendishly complicated.
* RISC-OS does not adapt to its situations. RISC-OS fundamentally is still
designed to work well on an Arm2 TV standard resolution 512k machine. Running
it on an Arm700 series XGA+ 256Mb machine does not give huge improvements.
Nor does plugging in a SCSI card automatically cause it to be registered and
usuable. You have to go through a whole range of programs first.
* RISC-OS has a very limited method of managing memory. The shared resource
of the RMA gets badly fragmented, leading to huge quantities of memory being
wasted after extended use. Data up to memory available can normally only be
edited, as RISC-OS does not provide virtual memory of any kind. These
restrictions cripple programs running under RISC-OS.
* The facilities offered by RISC-OS to its programs are mediochre. They
never were great - in my mind never finished - but little things like OLE,
external editing of files, hotlinking, multiple views in different
applications, standardised scrap filing etc really detract from the power of
RISC-OS.
Also, there is no standard method of making code multithreading. You can't
have a spreadsheet in one window recalculate while you work on another in
another window in the same program without a lot of hacking on the
programmer's part. Very few programs offer this, and quite rightly too.
* RISC-OS does not provide help for users. Compared to Windows 95, where
things are stepped through bit by bit by detailed hypertexted documents,
RISC-OS just displays a message up to 256 characters in a window.
* Filetypes are incompatible. Trying to load a GIF into Paint usually won't
work, unless you run it through an intermediate program to convert it first.
RISC-OS is extremely inflexible in this area - add to the above, neither will
it display unknown file formats in their native format. This means costly
amounts of memory being used to view a compressed filetype.
* A lot of the RISC-OS window manager has become obsolete. Things like window definition blocks specify a whole amount of information which it nowadays totally useless. This in turn has led to a very bodged 'pretty' effect on the RISC-OS desktop, and things get very messy.
* RISC-OS does not offer superior compression facilities, and neither is it
particularly future-proofed. RISC-OS 3 offers Squash, a facility difficult to
use and can only use LZW compression, which compresses badly on many formats
(eg; sound). This relates to the point above in the way that a program can't
play an MPEG or Replay without using one of a dozen propriatary methods.
RISC-OS still uses a combination of 'magic numbers' and RGB to specify colours, and so the latest machines facilities aren't used to the fullest. This relates to how RISC-OS doesn't expand to the machine it's living in.
[1] when I say disc i/o doesn't multitask, I refer to all disc i/o. Things
like file copying and formatting multitask due to the revised filing system
on RO3+, but simple loads and saves don't.
[2] I discount Econet here in this statement. Acorn's propriatary Econet was
very clever - but by the time the Archimedes series was established it was
woefully outdated. Newer versions of RISC-OS do contain Acorn's TCPIP stack,
but the way it integrates into the environment is shoddy at best. Something
coming closer to Window 95's method is a better idea.
As you can see, the list of cons far outweighs the list of pros. And note
nothing has changed much since RISC-OS 2. RISC-OS 3 added a large number of
extensions to the original RISC-OS, but a lot of these have since been
replaced with third-party extensions. In some people's minds, RISC-OS 2 never
got finished.
The future:
-----------
So how does this affect everyone in the future? Well, more than likely
Acorn will adopt a propriatary multiprocessor system based loosely around
TAOS, and will rewrite RISC-OS to run on it [3]. This RISC-OS that we see may
be considerably different to the one we know today.
For a start, it probably will implement mulittasking in the kernel, and
the GUI will be shifted into assemblation with the kernel, like Fileswitch.
In fact, a lot of RISC-OS may be changed to function like other operating
systems, probably based a lot on Unix. More than likely life will be
considerably different.
[3] I base this on that Acorn are unlikely to develop a completely new
operating system completely incompatible with existing RISC-OS programs. I
would suggest they'll bung a dozen Arm's together and rewrite RISC-OS to use
the multiprocessor facilites. Meanwhile, old programs can still run correctly
by being only executed on one processor. In other words, only new programs
would fully exploit the multiprocessing latitude.
But we're not here to talk about the future of RISC-OS - or are we? In many
ways, what tornado implements is what the future RISC-OS's will have - in one
form or another, because tornado should still be able to run on a
multiprocessing machine just like existing programs.
Probably the best way to show how tornado is going to do this is to comment
on that long list of pros and cons I gave above. Keep reading - but please
feel free to skip anything you don't understand completely.
The advantages of tornado:
--------------------------
Extensive drag & drop facilites ...
Tornado preserves that, and also automates a lot of it through its visual
editor. It also adds standard facilities for OLE, hotlinking, external
editing and multiple viewing. All these, shared amongst all programs, makes
the desktop considerably more powerful.
Another minor fact is that any files loaded into or being edited by a
tornado application are in actual fact owned and managed by tornado, not the
application. This allows tornado to share files between tasks, or to save
files out when an application crashes. The amount of usability gained by this
single addition is incredible.
The ability of a program to assume complete control of the processor ...
Also preserved by tornado programs informing tornado when they're going to
do this. This allows tornado to start preempting them, or if suddenly polling
stops without tornado being informed tornado can start up the crash handlers.
No application has control or precedence over others ...
Under tornado, an program can be given more time easily [4].
Multitasking on other systems is far more fluid and consistant ...
Under tornado, all programs are preempted under the tornado multitasker,
which runs alongside the RISC-OS multitasker, the window manager. To decribe
how the tornado multitasker is outside the scope of this document (but there
is more information at [4]), but be assured that it intelligently uses a
combination of preemptive and non preemptive multitasking and multithreading
to vastly improve program performance.
One of tornado's main aims to to improve multitasking. Printing and *all*
disc i/o under tornado multitasks [5] and subtasking is available to have
heavy processing done by tornado and not by your task [6]. An incredible
difference shows when programs are written properly - the desktop becomes
fluid, and tasking does not halt momentarily.
Also, I'll just mention that while tornado programs run entirely under
their own multitasker, and do not use the Wimp whatsoever, tornado uses the
Wimp to put tornado windows alongside Wimp ones, allowing partial interaction
of the two systems as far as the Wimp can be made to go. Note also that
tornado redraws its own windows, including frames, and these different window
frames posess quite a few additions to make life easier, like an iconise
button [7].
All tasks on RISC-OS are equal ...
Well, they aren't on tornado! :-)
Tasks on RISC-OS take as much processor time as they want ...
Again, under tornado they get given what tornado gives them. They may ask
for full processor control, and while they may get it they also may not.
Either way, the task will not know if it is still being multitasked.
Writing programs to run under RISC-OS is a real chore ...
Tornado runs programs written in a 'visual' manner. While programmers can
do this manually, it is even more work than the RISC-OS method - far better
is to get the tornado visual editor [8], which allows combination of C,
assembler and Basic in one program. To write a program visually, you create a
window template frame. To this frame you create windows, and in the windows
you create icons. To the icons you then attach sections of code in C,
assembler or Basic. You can also attach code to user-defined tickers & timers
and events, or attach code to windows themselves. By the way, when I say
'attach' I mean it very literally - you actually drag a tool/link etc from
the toolbox/linkbox etc onto an icon/window.
You then can save the executable, which amalgamates all the code into the
various files and saves the entire lot as a directory. This approach to
programming makes writing multitasking code so easy and quick.
Programs not written to multitask on RISC-OS can't be made to ...
Under tornado, when you hit f12 a window opens on the screen with the
*-prompt in it. When you double-click on a Basic program, a window opens and
the program gets executed in it. Or if you wish, the program can take over
the machine like it used to - but if you want to visit the desktop, hitting a
hotkey will bring you there, while the program continues to multitask on its
own. Another option available is for the program to take over the screen and
sound, but multitasking continues in the background. This allows multitasking
servers eg; fax servers to continue to work, but still allow you to see the
program's display in its entirity. Note that only programs that are enabled
to do so will multitask during full-screen operation - so a word processor
for example wouldn't multitask if you didn't want it to - leaving more
processing power available for the full-screened task [9].
Programs which crash on RISC-OS aren't handled well ...
When a program crashes, for whatever reason, polling is suspended on that
task and a window appears and asks the user what he/she wants to do about it.
The user may choose to continue regardless, or save out the files currently
being edited by the program and then force an exit.
This also applies when an application decides to depart without telling
anyone. Whatever files loaded into that application can be retreived. Or, if
you want, when an application shuts down due to an error, its files can be
saved out and a new copy of the application loaded in and the same files
reloaded back into it. And all this happens in the background, while
everything multitasks along nicely ...
External access isn't handled well ...
On tornado, a number of device drivers exist. Quite simply, tserial:
refers to the serial port, tparallel: refers to the parallel port
[THIS WILL BE FILLED IN LATER AS AND WHEN THE DETAILS ARE FINALISED]
RISC-OS does not adapt well to its situations ...
Unlike RISC-OS, tornado uses its advanced memory management facilities to
make full use of any memory available to it. It also uses any disc space you
have for virtual memory (and note only whatever shouldn't go into RAM goes on
the disc, thus losing you the disadvantage of other system's swap files which
must be a multiple of RAM size etc). Tornado uses the 24 bit RGB method to
describe colours in all cases. For higher spec machines, tornado will
calculate and render appropriately scaled down sprites and icons for the
current palette/screen mode. On the other hand, if you have a low powered
machine but a large fast hard disc, tornado will cache any rendered
sprites/icons on disc, with a secondary cache in memory, thus not hacking out
more CPU power than is necessary.
Unlike RISC-OS, the tornado system heap can be any size up to machine RAM
size (the RMA has a limit of 4Mb); applications can have a slot of anything
up to machine RAM size too (RISC-OS limits this to 16Mb); both of the low and
high resolutions tornado shared sprite and icon pools can be up to machine
RAM size too.
Also, under tornado, when you open the top and plug a SCSI interface card
in, it automatically is installed and becomes immediately available for use.
No more twiddling with configurations, although this still can be done if you
really want!
Now, whether you own the latest RiscPC 700 series or a lowly Arm2 A310,
you will have a system than runs appropriately to your computer's available
resources.
RISC-OS has a very limited method of managing memory ...
Tornado implements a vastly enhanced memory managment system, which is
available for all programs to use. It allows private heaps, RMA heaps, heaps
in heaps, postslot heaps and of course it manages the tornado system heap, as
