The aim of the datatype- concept is, to standardize and facilitate
the use of application programs with any kind of data. When using
external data (graphics, animations, text, sound, etc) a programmer
no longer has to take care of the data type, since the loading of special
file formats (JPEG, IFF, ASCII...) is done by the datatype. This means
that it does not matter at all, whether the user selects a JPEG, an IFF or
a GIF-graphic as background pattern.
The datatype-system is object-oriented and has a modular sturcture, so that
additional datatypes can be added without any problems, which can then
be used by the application programs without any further action necessary.
Under p.OS, the datatype-concept is consequently kept. Even the gadgets,
i.e. the graphic in- and output elements of the user interface use this concept.
This means, that graphic files of any format (depending on which datatypes
are installed) can be used e.g. as button graphics in programs.
Please also see Shell-commands DtType and
DTT.
See File system
The file system is the part of the operating system that organizes the volumes
into directories and files and which is used by (most) applications to access
the data saved there. In other operating systems, even the directory structure,
resp. the volume or the proper disk-partition are also called "file system".
Also see section File system of the
documentation.
Devices are libraries, providing the functions
to access devices, e.g. volumes, interfaces or other... Under p.OS, the "pSCSI.device"
is e.g. responsible for the access to devices, connected to a SCSI-Bus (or to a bus
system similar to this, e.g. IDE/AT-Bus).
In contrast to the device concept of most other operating systems, under p.OS
the devices are completely asynchronous, i.e. an application program may
induce a device to execute a certain action and does not have to wait until this
action is finished but may execute different tasks in the meantime.
...drag and drop is not to be taken literally and does not mean to
drop the computer from the desk...
What is meant, is the possibility to move an object (icon, text, pathname, etc.) to
another one on the screen, by pressing a mouse key (default setting under p.OS is
the center mouse key, or CTRL+left key in case of two-key-mice). The result then
is a useful action depending on the object that has been dragged and dropped as well
as the place where it has been dropped.
Also see section Drag&Drop of the
documentation.
Gadgets are basic elements of the graphic user interface.
They are elements receiving user inputs (buttons, sliders, text entry fields),
and they may also be used to output information. However, there are
gadgets as well, that are both at the same time (e.g. the list requester
of the p.OS-Filer).
Under p.OS all gadgets are object-oriented.
See also: object oriented
and System-Gadgets of the documentation.
"Graphics Image File" is a graphics file format developed by
Compuserve for use in online-services, saving graphic data
LZW-compressed (similar to the method used by the LHA
-Archiver). This file format allows to save animations, transparent
backgrounds and an "interlace"-option, but only supports graphics
up to 265 colors.
This p.OS-version includes a Datatype for this file format.
Recently, Compuserve claims its copyright, which has lead to some
problems. The new, freely distributable PiNG-format
is intended to replace GIF.
The small graphics, the icons, serve to graphically represent an action or an object.
Under p.OS, the graphics representing the volumes, files, directories and programs
on the p.OS-Workbench, are usually called Icons.
Also see Icons-Sectionof the documentation
Interchange File Format. Lots of file formats for many different files, like
Bitmap-graphics, formatted texts, vector-graphics, music, samples, preferences,
animations etc. hide behind this abbreviation IFF. All of them are devided into
so-called "Chunks", i.e. sections of different length containing different data.
p.OS already contains Datatypes for some IFF-formats
in the present version.
Joined Photo Experts Group. This group of developers invented a file format
that allows to save pictures (especially photographs) in very compact files,
thanks to the use of sophisticated data reduction algorithms. The
file format itself is called "JFIF" (JPEG File Interchange Format), however,
the file name extension .jpeg or .jpg is usual for picture files of this format.
p.OS already contains a Datatype for this format.
Libraries are used by application programmers but as well by
the operating system to a large extent. They contain functions, executing almost
everything related to the operating system. However, application programmers may
also create their own libraries to either allow others to use new functions or to modularize
their own software.
The files in the p.OS-system directories ending in .library are so-called
"shared libraries", i.e. they may be used by several programs at the same time,
although they are only once loaded into memory. With this, the operating
system becomes more compact. Other operating systems are using this
principle as well, since it offers lots of advantages. However, these OSs need
an additional program, that links the functions from the libraries with the applications
when starting the program (runtime-linker). This is not necessary with p.OS, since the
Library-concept works a bit different - just like in AmigaOS - being a basic element
of the system right from the very beginning.
Under p.OS the following important libraries exist, which are indispensable:
pExec.library (program execution control, multitasking)
pDos.library (In- Output, device access, volumes)
pGraphics.library (Graphics output)
pIntuition.library (User inteface, Windows ...)
MESA is a software package for programming in the graphic language OpenGL.
OpenGL is a popular standard for 3D-Graphic programming. This software is
already available for p.OS.
In some other operating systems, this still sounds like a new magic word
the Amiga-user however is used to it for many years. To execute several
programs at the same time is probably one of the most important features
of a computer, even if this fact still hasn't come so clear to the bosses of
some large software companies.
p.OS, as well as AmigaOS, allows "prioritized, preemptive Multitasking",
with programs being "reentrant" and "reexecutable". Here as well, p.OS
offers some new features. To clarify some of these terms: "preemptive"
means, that the multitasking-principle is completely transparent for application
programs, so that these only have to take care of their own processes.
The operating system distributes the processing time among the different
tasks, depending on the priority. This cannot be influenced by the application
programs. (However, there are two exceptions ...). The counterpart would be
"Cooperative Multitasking" (Windoze95), where the different programs have
to cooperate to make the system work.
"reentrant" are programs that may run several times at the same time, even if
they are in the memory only once.
"Reexecutable" means, that a program can be repeatedly executed, without having to be loaded again each time.
If a program is not only able to execute the tasks in linear sequence but
also parallel, i.e. if it devides itself into several parallel "threads", this
is called "Multithreaded". The p.OS-Workbench, is such a program,
that seems to execute different tasks simultaneously, so that the user
does not have to wait.
p.OS is called "object-oriented operating system", since first of all,
it allows the user to work in a most natural way, and second, since the
programming of applications is done according to object-oriented principles.
In general, "object-oriented" means, that those data belonging together can
consequently also be processed together so that we do not have to take care
of data, which are not of interest to us.
Thanks to theDrag&Drop-concept the user
inteface allows e.g. to move an object, i.e. a (file-, volume or directory-) icon,
a character string, etc. to any position desired, where the corresponding action
will then be executed. We do consequently not have to take personal care of the
proper content of the object.
For the programmer, "object-oriented" means a lot more than this. For example,
the Gadgets as well as the Datatypes are
organized in an object-oriented way.
An example:
The term "Gadget", object orientedly speaking, is a "class", i.e. the name for a
group of objects having certain characteristics in common. For example, all
gadgets have in common, that they may have a frame and a content, that they
occupy a certain position in the window an that they are able to receive messages
from the operating system.
The great variety of different gadgets, results from the fact that from the
general class "Gadget" new classes arise by expanding them by very special
features which can again be extended until a set of different gadget-types has
been created. Such a gadget-type (Button, Listview...) is then referred to as "derived
from the class gadget" or "Sub-class of the class Gadget". The term "Sub class"
is used as well. The class "Gadget" in return, is called "Basic class" or
"root class" of the other gadget classes.
This process can be continued endlessly, so that real class-hierarchies can be built,
which are topped in the highest level by the basic class (root-class), from where
the specialized classes are derived. Those form again the basic class for the highly
specialized classes. There is a sample program for p.OS, allowing the graphic display
of the class hierarchy of the gadgets in a window. (SYS:Tools/ClassList)
"To patch" means to subsequently replace parts of the operating system against new
parts = patches.
Since this is usually done during the runtime of the operating system, this is quite
a risky thing. It might happen, that several programs try to patch the same part of
the system or that other programs simply assume the original status of the system.
These programs will then consequently either run with errors or the cause a crash
of the system. This can be observed more and more often, with the rising number
of PD-commodities under AmigaOS. In case of commodities, it is mostly functions
from the system libraries that are patched. These will then no longer execute the
same action as it was originally meant. This is quite dangerous...
See section Configuration-of the documentation.
There are things in life that You better don't touch:
Some Programmers still assume certain data at certein memory
addresses and make a philosophy as well as application programs
out of this rather ancient assumption.
If You are a programmer: Always use the provided library functions,
don't access OS structures other than this way!
Retargettable Graphics. This means, that the graphic drivers is
structured in way, that the graphic output is not restricted to a certain
ouput device, but may be sent almost anywhere only depending on the
driver software installed, i.e. also to a network, a printer, etc.
Small Computer System Interface.
A bus system, where primarily hard- and removable disks (e.g. Zip-Drive),
CDRom-drives, magnetic tape drives and scanners are connected. To the original
SCSI-II-Bus up to 7 devices can be connected. Some new versions (Wide-SCSI,
Ultra-Wide-SCSI etc.) allow up to 15 devices. Under p.OS these devices are
addressed from application programs (e.g. ZipTool)
via the pSCSI.device, already supporting up to
15 devices as well, with the devices 8 through 15 being configurable at p.OS-Startup
See section Shell in the documentation.
A "Stack" is a special kind of memory organisation. The data stored in it are
treated according to the LIFO-principle (Last in- first out), i.e. like with a real
stack, something is put on top to be saved and can subsequently only be taken back
from the top - and not from somewhere in the middle of the stack.
All programs running under p.OS use this storage provided by the O.S. for some
of their internal data. How much of this storage is needed, depends on the programs
but sometimes as well on the data that these programs deal with. Therefore, the stack
size can be changed in the Shell. Also see the Shell
command Stack.
Graphical user interface in p.OS.
See section p.OS-Workbench in the documentation.