This page ought to contain examples and wishes about what
Tunes should actually do as a better computing system.
It's a new page in there, so please excuse its still being a draft.
Please also do send in your wishes for a new system...
Herein, we present examples of conceptual differences which make
Tunes a completely different system from existing ones.
Also see the Examples page for concrete
interaction examples with the Tunes system.
Imagine you have a beautiful, perfect, database, but you're using
text with a non-standard encoding (specialized ASCII extension, with
specialized fonts).
On existing systems, you're stuck, because the
database will get mixed-up between ASCII control characters and your
encoding, and even if your encoding doesn't use these, you won't be
able to sort your entries according to the usual order from your
encoding. Input and output will be a pain, and mixing ASCII and your
encoding in data fields will be impossible.
Using Tunes, it's not a whole monolithic database application being
provided (sold/given/whatever) to you, but a set generic database object,
that manage the database-specific stuff, but are completely parametrizable
as for the kind of managed data. Thus, you can manage usual ASCII text as
data, but also any kind of raw data with any kind of manipulation properties,
any kind of sorting orders on it, etc. Standard multiplexers will allow
you to mix different kind of data in one data field, etc.
Imagine that you've just made your own data-acquisition hardware for some
specific job you're doing.
On existing OSes, you'll have to also rewrite
all the software from scratch, or pay very expensively some company to
integrate support for your hardware in their software product; in any case
it'll cost you lots of time and money, and you'll be stuck to the specific
package you choose, unless you're ready to pay again the same large
investment all again.
In Tunes, you'd just write just a generic driver,
that would run on just any software package you'll ever have,
because they are generic,
and really take as an input any module that provides the good basic operations.
Imagine you really need just a small little feature to be added to some
software you have.
Existing systems are coarse-grained: you cannot isolate this feature from
lots and lots of other features you don't need.
Either you choose to write your own software, and need reimplement all the
existing features of the software you already have before you can add your
own; or you buy some new software, and will have to buy not only just your
feature, but many features you don't need, which not only will cost you money,
but also occupy memory, thus slow down your computer as well as prevent you
from installing other useful features.
The whole world is a victim, as this forces people to waste lots of
computer hardware to manage lots of useless features,
the economical and ecological cost of this being tremendous.
By providing fine grain, Tunes will enable people to
have just the feature they need, which will greatly reduce the cost
of software for the individual as well as the global environment.
This would lessen the price of hardware required for some software,
of a software package, make software development
easier and
All these prices are in money as well as provider and consumer human time
and pollution.
All that is possible because Tunes allow fine-grained modules
to be delivered, not huge "applications".
Imagine that you want to access directly some computer capability,
because the standard services won't allow you do so.
Then, even though what you want is directly accessing the I/O ports,
traditional system kernels will add a penalty at each access,
by first intercepting each of them. Sometimes, the penalty is so
large that you just can't do it; then, you must create a big security
hole by modifying the kernel, or allowing direct, uncontrolled access
to the I/O ports; in either case, this means no "normal user" can do
it.
Using Tunes, you can access directly any visible object; either you
cannot see the I/O ports you need, or see them wrapped in secure
software layers, or you see them directly; every single object can
be visible independently from the others. Hence, you may well see,
say, the serial I/O port, and use it, without your needing be super
user and have access to all other ports, and without a system kernel
intercepting all your accesses. You just see it and access it directly.
If some access combinations may endanger the system, you can either
see the I/O directly wrapped by an adapted combo detector (based on
actual dangers, not user-access rights that are independent from the
user being able to use the port properly), or statically prove
that all your accesses will be all right.
In either case, your performance is quite better than that of a kernel,
and you have a much more secure system, as you're not filtered by
a static, unadapted kernel, but by dynamically adapting tools.
The system isn't trying to conform reality to arbitrary bureaucratic
layering, but adapting security to actual hardware and software
requirements.
Computer power is expensive.
In today's computer networks,
it is wasted: most of the time, most computers stay idle.
Though using the full power of the network is theoretically possible
today,
existing programming languages and tools are designed to
run on a single computer, the one on which the user is logged.
To take advantage of the computer horsepower on the network,
a user has to explicitly write his program for that, for which he
can find little to no help.
Moreover for security reasons, he most idle computer won't accept
to work for him, and he will have to manually manage all the
possible failures of the network.
With Tunes, computer power could be fully used:
the system is built to automatically distribute code over the
network, in a way that conserves security for both the one
who furnishes the power and the one who uses it. Users don't
have to rewrite everything from scratch, though they
still can modify the details of everything to suit
their needs. Thus, computer power is must less wasted, which
leads to cheaper computers for higher effective horsepower.
Data integrity is important
In existing systems, you have only lame slow unadaptable centralized
architecture.
With Tunes,
you could distribute copies of data accross the network
so access it quick, yet have the same security, and be much more
maintainable (see notably the Amoeba stuff).
In existing systems, you must manually provide all the modules a program
you install needs. Being painful, unadaptable, it leads to huge systems
with lots of redundant modules, everyone being painful to install and
maintain, and slow module upgrades. Moreover, you have absolutely no
security on the modules you use.
In Tunes, the system may automatically fetch the modules you need,
and ensure that no one may cause harm through proof systems and
trust systems, while keeping saving all the data the human user
manually approved of.
In existing systems, you must manually give all references to the computer
so that it does specific actions on a specific computer.
It leads to awkward system interaction, and waste of both
human and computer resources, as human must give trivial details, and
do not have time to manually schedule computer activity, nor
proficiency to do it efficiently.
With Tunes, the system may automatically dispatch the information
flow among the computers, according to general human defined
constraints so as
In existing systems, .....
With Tunes, the entire world may be virtually running the system
with mostly isolated computers being considered
as having very slow and unreliable network links.
In existing systems, you have to explicitly save. How many times have
work been lost because it wasn't automatically saved, whereas the
computer was shutdown, or crashed, or their was a power shortage ?
In Tunes, everything is automatically saved,
In existing systems, all changes are irreversible,
so you always fear
Tunes will save a log of changes at a fine grain, so they be
reversible. Saving will be adapted to the objects, not added
on far away layers of the system, so they will reflect actual
changes more efficiently, with much less memory consumption.
In existing systems, you must learn tons of different specific
completely different languages, each having its powers and its
flaws, because when something lacks in existing languages,
you must
In existing systems, .....
With Tunes, objects are defined according to their semantics,
to what they actually mean, to their meaning, the way they interact
with other objects.
In existing systems, you are forced to trust blindly or not use.
Users trust software only according to their origin,
and big software firms dictate their whim the non-technicians.
With Tunes, software may come with proofs of their correctness,
and feedback from users about the software and competing products
is freely available, not hidden from the customer.
.....
Tunes will be a system
resilient
to network failures.
In existing systems, you're never sure what happens when a failure occurs,
but you're sure than it will eventually occur.
With Tunes, all objects are failure-aware,
and you may define failure policies, .....
Conclusion
We believe that all these features are linked:
old
To Do on this page
Produce a table of contents (TOC)
Add lots and lots of examples.
Add pointers to other example pages.
Find a suitable format for OS comparisons
Point from example points to theoretical points, and conversely.