What is RISC OS to me?

Why this question?

There are those looking at changing some aspects of RISC OS.  This leads to
the question of how much many be changed before it is no longer the OS that
is known and loved.  Now there are of course going to be varying answers,
some it is the purity of the entire OS, in all ways to be left unchanged, and
there are some for whom it is only the look and feel that really matter.


****************************************************************************
So What Makes RISC OS the RISC OS That I like?

There are a few things that make the OS what it is for me. These include:
* The Module Oriented nature of the OS as a whole.
* The ease of programming.
* Vectorization of many OS operations.
* The ARM ISA to which so much of the OS is tied, in my view.
* A Window manager very unique in nature.
* Star Commands implemented by modules, aliases, and named executables.
* The way that Drag and Drop permeate the user interface, simplifying so
  many operations.
* The Desktop Environment.
* The open nature of the system, inviting one to write there own utilities
  when they need to do something simple.
* How easy it is to modify the behaviour of the OS to allow simplification of
  writing applications.
* Filesystems implemented in layers, each layer being of a fairly simple
  nature.
* A simple directly buffer oriented sound system, that makes simple its own
  extension by adding voice generators, or other similar bits.
* Graphics operations that are clearly defined, and very simple to use by any
  application.  Ranging from b`basic vector operations (OS_Plot) to more
  advanced vector operations including grouping and Bésier curves (Draw), and
  inclusive of raster image manipulation (OS_Sprite and related), with a
  very clear implementation of clipping that effects all operations that draw
  to the screen.
* The font manager implementation, supporting both vector and bitmapped
  fonts.  Also the system font routines that allow the redefinition of any of
  the 8x8 bitmapped characters of the system font, and are mostly separate
  from the main font manager.
* The integrated BASIC V interpreter, with its integrated ARM assembler.
* The ability to play at any level with the OS, producing code that is both
  fun to write and very effective, with very little effort to do some very
  advanced things.
* The ROM, the whole of the needed system. As well as the programs therein.
* Much of the software that I use on a daily basis, and some that I use not
  as often as well.

That is in short what makes RISC OS what it is to me.  You could say that
some of this is the view of a hard core user, some that of a programmer, and
some the view of a RetroComputing user.  While I do not consider myself a
RetroComputing enthusiast, I am aware that many view the devotion to ISA and
binary compatibility as a RetroComputing view, so in that way it does apply
to me.  More so though I am about the day to day usability of the OS, as a
user of the OS (not some internet user that does not know the OS at all).


The rest of this document will be going into a little more detail in each of
the areas listed.  This is as it stands from my point of view, and as such
shows where I draw the line.  These are my views.


****************************************************************************
Modular OS.

RISC OS is composed of a number of modules, that allow for the function to
be well and clearly divided.  This is true of Hardware support for the most
part as well.  It is the use of these modules that allow for the range of functionality and ease of extending the function of the OS.

That is to say that the core of the OS is in the Kernel, which is a pseudo
module named 'MOS Utilities', then everything else is done in additional
modules.  Everything else, including filesystem, fonts, Sound, etc.  And the
modules are easy to understand as well as easy to write your own modules.

Modules may add functionality to the OS, be a type of Application, Provide for
a way to modify the behaviour of others, provide some other form of service,
etc.


****************************************************************************
Ease of Programming.

Do to the combination of an extremely well defined API and the simplicity of
the ARM ISA, it is extremely easy to write programs for RISC OS.  The same is
true of writing modules for the OS, thus providing a way to improve the OS in
various ways, sometimes in ways that are only used by a few programs, though
for the better.

This API is provided largely through SWI calls into the OS and its modules.
In addition to this there are a number of software Vectors that are part of
the API and allow providing alternative implementations of core functionality
or monitoring the use of various parts of the OS.  In addition there is also
a system of 'Service Notifications' used to notify modules and applications
that certain things are about to happen or have just happened.

When taken together this makes the OS a very much easy to write software for
environment, in ways that no other can quite match in all ways.


****************************************************************************
System Service Vectorization.

There are a set of standard Software Vectors, that can be hooked to call your
code when parts of the system are called.  These can be used to implement
some functionality, or to monitor some activity.

The filesystems are implemented almost entirely on top of vectors.

Then other vectors provide the ability to change or just monitor things like
standard output and input, graphics operations, screen operations, Sound
buffer status, etc.

Some also are a sort of implementation in themselves.  Like timing with
TickerV or FastTickerV.

Then there are the services that notify of things happening.  Like when a
module is killed, when some unknown calls are made, when parts of the system
are starting or closing out and many other things.

In addition there are ways to call code when there is time to run it, to do
things after certain events in user mode for example.

And of course there is the ability to register handlers for some common items
that a given application may wish to handle for itself.  These include Error
handlers, Abort handlers, Escape Handler, Exit handler, etc.

Because of this broad range of vectorization of the OS, it is easy to modify
the behaviour of parts of the system, even for a single application.  This
also makes it easier to do many things in programming than with other OS'
which often are more rigid in these areas.


****************************************************************************
ARM ISA.

For me the ARM CPU was introduced to me along with RISC OS (Actually Arthur
OS at the time, later became RISC OS).  As such programming for ARM and for
RISC OS go hand in hand for me.  As such running on a CPU that directly
implements this ISA is a big part of what makes RISC OS what it is for me.

The ARM ISA is very much eloquent in its nature.  With every instruction
being able to be executed conditionally, as well as being able to specify if
instructions effect the flags or not.  Then the flat Register set, that has
R15 as the program counter/pointer, and thus has the PC as a user register.

The addressing modes of Load and Store instructions are very well thought out in a way that is perfect for the ISA.

The simple nature of the instruction set is very very satisfying to work in.

And the one non-RISC feature of the ISA, the load/store multiple instructions
are very much appropriate as the one and only addition that is non-RISC in
nature.

On top of all of this is a potential for clean implementations that could
with ease exceed 4 instructions per clock in many situations (this is for
another document to detail), largely  do to the nature of conditional
instructions, as well as the way the instruction set is layed out.


****************************************************************************
Window Manager.

The window manager in RISC OS is very well designed and lean.  It is also
responsible for the handling of cooperative multitasking of applications.
The API provided by the window manager is so easy to work with as to make
the need of toolboxes non-existent for the most part, with very  little to
add that could make it easier to program for.

With everything very well defined, and all widgets implemented as cases of
the same simple structure (known as Icons in RISC OS) that supports text
widgets, sprite widgets, button widgets, label widgets, menu widgets, radio
button widgets, and groups.  This single form of structure for all widgets,
which are all called Icons in RISC OS, makes programming very easy.  It also
makes changing details of the user interface pretty simple with a minimal of
code to be modified if any.

Then there is the handling of menus, in a very clean way.  That is just a
very simple menu structure (simplest I have seen on any OS), a single OS call
to open the menu, and just handle the information given by a menu selection
event, which is very simple to do.  There is likely no system that is easier
to deal with menus in (with the possible exception of Intuition on Amiga).

Even maintaining multitasking while doing everything else in the cooperative
multitasking window manager is very simple to do.  As you just call your
event management to check for events, which calls Wimp_Poll or Wimp_PollIdle.

One of the event types is for a user message. There are a good number of
defined user messages, and they are all fairly simple to handle.  These are
even used to negate the need of standard file dialogs for open or save.

****************************************************************************
Drag and Drop.

In the RISC OS Desktop environment, Drag and Drop is everywhere, and better
than in most systems.  You can drag part of a file to the IconBar Sprite of
another program to work with the data in the other program without having to
use files inbetween.

Further saving is a real easy drag.  You give a file its name, then drag the
Icon Sprite provided by the application to a filer directory window, so you
see very directly where you are putting the file.  This solves the problem
that is very well known on other OS' of having to see standard save/load
dialogs in a different way than normal filesystem views.  RISC OS just uses
the normal file system windows (called Filer Windows) provided by the filer
(desktop file manager, like Finder in Mac, or Workbench in Amiga).


****************************************************************************
The Desktop.

The Desktop is composed of the IconBar, the PinBoard, the TaskManager, the
Desktop Filers, and all runs in the Window Manager.  It provides the environment that makes the drag and drop possible, as well as a place to run your
applications that cooperatively multitask and use windows on the screen.

The IconBar at the bottom of the screen since 1987, provides a place to show
Filesystems at the left, and running applications at the right.  All shown
as IconSprites.  With at the right most being the IconSprite of the Task
Manager, and next in being the Display Manager (palette on older versions),
followed by whatever programs you are running.  On the left are any disks
that you have access of, followed by the Apps which is part of ResourceFS and
gives access to commonly used applications in a convenient location, then any
other filesystems, often followed by other HW related things like printers.

The pinboard provides the background.  In every version since 3.0 it allows
you to have a background picture, as well as provides a place to 'Pin' things
(put there icon on the pinboard) for quick access.  When you Iconize a window
its Icon will appear on the pinboard as well.

The filers are what provide windows displaying the files and directories in
a filesystem.  They are used for most File Management, and fully support Drag
and Drop.  They are also where you drag files to in order to save the file.


****************************************************************************
Method of File Systems.

File Systems in RISC OS are so well thought out, They are implemented as
layers, where one layer provides the physical read/write and another the FS
details, in some cases a few levels deep to provide for different File System
and Hardware combinations.

These include one set of common combinations where a file stored in a file
system is itself a file system (a disk image if you will), and this is known
as an Image File System.

There is a lot to say on the file systems, though this just being what makes
RISC OS for me, this is good enough for this document.


****************************************************************************
Sound System.

The sound system is one of those things that people like and do not like.  It
is a different way around the problem of providing sound output for a diverse
range of Hardware, from the original 8-bit ulog sounds, to the common multi
channel 16bit sounds of today.  RISC OS has always allowed for a much more
diverse range of sampling rates than most other OS' did for a long time.

In its most basic form the sound system sets up two buffers, and calls on you
to fill one when empty, playing from the other.  This is the basis of the
sound system, on top of which the rest is built.  It also must be remembered
that there is the need to support the older 8bit sound system on systems that
natively use 16bit samples.  Though on top of this are mixing layers that
provide for multiple application access to outputting sound (SharedSound) etc.

This section I am keeping short, as I like the sound system I could write
quite too much here if I allowed myself to so do.


****************************************************************************
Vector Graphics.

The simplest layer of vector graphics, as provided by OS_Plot, and available
through VDU commands as well, is a very well thought out system of graphics
routines that work together.  These provide for the standard line, polygon,
Circle, Ellipse, and Arc drawing, both filled and outline only.  These are
plotted and correctly clipped by the screen bounds as well as the currently
set clipping area.

Then there is the extended functionality of vector graphics by use of the
Draw Module, as well as the related DrawFile module.  These use paths to
define boundaries, as well as objects composed of multiple paths.  Paths may
be open or closed, and may be implemented as line segments or Bezier Curves.
Objects created this way may be outline or filled.  And again they obey the
rules of clipping areas in a clean way.


****************************************************************************
Raster Graphics.

While this is something in common with most OS', RISC OS takes it a bit
further than most.  Most versions of RISC OS have the SpriteExtend module,
which takes and adds a lot of extra function to working with raster graphics.

Raster graphics in RISC OS are handled as a format known as a Sprite.  The
OS_SpriteOp calls provide functions for manipulating sprites in many ways.
These include rotation, scaling, skewing, inserting/deleting rows/columns,
doing more advanced transforms by a standard transform matrix, etc.  And this
is basic functionality in the OS.  When plotting a sprite the clipping area
is obeyed cleanly, as are the screen bounds.

****************************************************************************
Clipping.

A clipping area is a rectangular area to which graphics or text or both
output is limited.  This is a very important feature of the Graphics system
as a whole as it makes windowing much simpler to implement, and thus is a big
part of why the Window Manager works so well in RISC OS.


****************************************************************************
The System Font.

Now days it is somewhat rare to hear someone say much about the System Font
and its use.  It is very flexible, in that it is a simple 8x8 pixel bitmapped
font, though with the ability to redefine any single character definition.

This may not seem like much now that using the Font Manager is so common.
Try instead to think about its usefulness in simple game graphics, or other
simple graphics.  It can save a lot of work for many an application that is
able to take advantage of it.  As with other graphics operations it follows
the clipping area, and screen bounds in a clean way.


****************************************************************************
The Font Manager.

One of the best Font Managers of any system is that built into RISC OS.  We
have had vector Font Support since about 1989, so before the others added
this kind of font support.  Add to this the support for antialiasing of fonts
in a manner that is very cleanly done, in my opinion still today better than
other Systems.

Of course there is also support for bitmapped fonts of any size, and vector
fonts are converted during use for faster rendering.  The format of the font
for bitmapped usage is 2bpp instead of the more common 1bpp of other systems,
this allows for the definition of how much to blend in for antialiasing, thus
making the font system a little faster while keeping extremely good support
for antialiasing.


****************************************************************************
BASIC V, and its Assembler.

It is very nice to be able to knock together a small program in a hurry, and
to do so without having to load additional tools.  BASIC takes care of this.

For quick prototyping the included Assembler can save some time, a lot of
time.  And if you want to distribute source code, it is for certain that
every RISC OS user has BASIC V, so it is a good format for the assembler that
you want to distribute, especially if you wish to be sure everyone has the
needed assembler.


****************************************************************************
The OS that can be played in.

Without restriction, playing in programming in RISC OS, trying out ideas,
even to the point of stuff that ends up kicking the OS out (as in other OS)
is always something that can be done in RISC OS.

There is no restrictions on playing with possibilities in RISC OS, and it is
very much easy to do.  Likely one of the best features of RISC OS is that
nothing is off limits to playing with changing up or modifying of the OS and
how it does what.


****************************************************************************
The ROM as the Base of the System.

Having a complete working system together in a ROM or ROM Image file is very
helpful, especially when something goes wrong in some way.  It also gives a
very good concept of a minimal complete system, as the ROM embodies that.

Now if ROOL would stop making the system pop an error box when there is no
boot sequence, it would be nice.  Do not know why they added this little bit
of annoying crud to the desktop startup when working without a boot sequence.
Sometimes we by intent whish to work on a 100% minimum system of the version
we are using, and that means no boot sequence, just the ROM for the OS.

Everything needed is within the ROM.  Configuring can be a bit of a pain, as
with current versions the Configure Application has been removed from the ROM
though it is still possible to do it all from star commands.


****************************************************************************
The Programs in ROM.

Mentioned one that has been removed above.

The other ROM applications include
* BASIC V : The Basic Interpreter.
* !Edit   : A good text and BASIC program editor.
* !Paint  : A decent Raster Graphics Editor.
* !Draw   : A very good Vector Drawing program, with a lot of extra features.
* !Alarm  : A clock with event shcedular buitlin.
* !Help   : A program to provide popup help in programs that support it.
* !Calc   : A simple 5 function Calculator, boot sequence replaces it with a
            scientific calculator.

****************************************************************************
The Programs I use in RISC OS.

Then of course there are the programs in there diversity that I use in RISC
OS.  These are part of my usage, so worth of a metion herein.

I could never even attempt to remember every little program I use, some more
than others.  Though here is a quick and only partial list:

* Netsurf  : Very Good web browser And it lacks Java Script even better.
* FTPc     : FTP Client.
* Ovation  : Word Processor.
* !Zap     : Programmers text editor and more.
* StrongHelp : Programmers Help Reference System.
* GraphTask : Allows running some graphics BASIC progs in task window.
* ACEFILM   : Movie Player for AceFilm movies.
* QuickFlic : Movie Player for old type FLIC movies.
* SndFlic   : Movie Player for FLIC with Sound, with streaming support.
* ffmpeg    : Movie player and format converter, many formats.
* KinoAmp   : MPEG Movie Player.
* CineWrks  : Movie Editing package.
* 3D-Edit   : 3D Modeler.
* NetRadio  : Streaming Radio.
* Docktor   : Program Launcher.
* MiniTime  : Desktop Clock.
* ArchiEmu  : Acorn Archimedes Emulator (and whole second list of progs).
* InterGif  : Creates GIFs, including animated, from sprites.
* PrivateEye: Picture viewer, with export for Sprite, and tags view.
* Merlin    : 3D editor for raytracing.
* Ray3DPro  : Raytracing software.
* POVRay    : Persistence of Vision Ray tracer.
* Thump     : Thumbnail view in filer windows.
* ChatCube  : IM Client, includes group chats.
* SiteMatch : Web site syncronisation.
* ASM       : Good Assembler.
* ExtASM    : Another good Assembler.
* !ABC      : BASIC V Compiler.
* DDE       : Acorn Desktop Development Environment, includes C compiler.
* AsAsm     : Pretty good ObjAsm compatible assembler.
* AppStat   : Application monitoring.
* VecStat   : Vector usage monitoring.
* SWIstat   : SWI usage monitoring.
* BaseN     : Programmers Number Base Conversion.
* BitField  : Bitfield helper.
* SimpleGit : For accessing GIT repos.
* TemplEd   : WIMP Template Editor.
* DRLink    : AOF Object Linker.
* InfoZip   : Zip format archive tools front end.
* ArcFS     : For arc archive files.
* UntarBZ2  : For when I grab a ROM source tarball.
* Snapper   : Desktop Screenshot tool.
* PDF       : For viewing something, hmm.
* TaskUsage : For monitoring task slot time aparrent usage.


That should be a decent outline.  If I was to really take the time to do a complete, or even halfway complete list it would be many times longer than that
, at least 50 times if not more.

Of course I did not mention any of the games I play.  I also intentionally omited anything that I wrote.