TUNES Manifesto [draft]

[Tril]

I propose the following document as a TUNES manifesto.                          
If I am severely wrong, and you disagree this is where tunes should be          
going, let me know, and I'll call it something else ("Tril's project            
manifesto" :).                                                                  
                                                                                
-----------------------------------
TUNES Manifesto: Redesigning Computing [Draft]

Programmers have too much power and too much responsibility. They can
control everything on a user's computer and they feel a need to do so. 
There is a widespread belief that programming is a black art, that
normal people cannot understand, and shouldn't want to.  This belief
perpetuates a stratification of technological society into elite knowers
and the ignorant, who are at the mercy of whatever new download they can
get their hands on today.  The opposite belief, that any user can be a
programmer, and get their computing job done, should be established and
eliminate the threat that one segment of society will gain control over
another.  Whatever factors that make programming and using a computer
difficult, that make code incomprehensible, and that make computers not
obey their users, should be eliminated.

The software crisis is created by a surplus of ideas for what people
want computers to do, and a shortage of willing and able programmers to
make the computer perform.  Ideally, programmers would be not needed and
the computer could program itself.  If a user can communicate to a
computer what is needed, and it is done, then the software crisis is
solved.  The lack of programmers means everyone has to cope with
software that doesn't do exactly what they want.  This wastes time and
creates frustration, only broadening the gap between elite programmers, who
laugh because they know how to get the computer to do what they want,
and ignorant users who only struggle.

In addition other problems exist in computing: Bloated programs that
have features no one will ever use, platform incompatibilities, frequent
crashing, rebooting, reinstalling.  Debugging is difficult.  The bloat
is defined as a feature exists that the user doesn't want.  If the user
could take it out, there would be no bloat.  A system is needed that can
run on every platform.  Crashing is defined as the program violating its
specification.  Rebooting is a result of inability to modify running
state, or to correctly propagate dependency change.  Reinstalling is
often required to wipe out the mess that is accumulates from dozens of
poorly written programs trying to share the computer.  It's better to
get the program right in the first place than to debug it, but either
way, it takes too long to test the program and any changes to it because
of compilers optimized for running speed, not "reflecting speed", the
ease and quickness of making a change and seeing the results happen.

Computer science research diverges in a zillion directions. Distributed
computing, object oriented languages, orthogonal persistence, reflection
and artificial intelligence, are only at the beginning of their growth
and are having trouble because research requires code, and code is
either written with proprietary restrictions, or it just takes too darn
long to write a program that works.  Instead of trying to read all the
papers out there and make a system that incorporates all the ideas,
which would be impossible, we'd like to make a system that allows and
encourages experimentation, is easy to modify within itself, and is safe
to play in, so that all the research that people really want to do can
be done.  Hopefully this will unify computing research because if
everyone does research on a single system, each advance can benefit all
the rest.  We can only try to make a system flexible enough to handle
such diversity.

The free software/open source community is large, and growing rapidly.  
However, there's still much proprietary software.  It's not clear that
proprietary software is going away anytime soon.  What the free software
community needs is a big push to get the attention of the whole world, and
to make people realize that proprietary software is stupid, wasteful, and
an offense to all users.  What better way than a system that takes all
source code and keeps it around at all times, and requires it to work
properly?  If the system is good, and better than everything out there,
wouldn't that convince proprietary programmers to switch over?

The Internet has gaping design flaws such as being completely vulnerable
to Distributed Denial of Service Attacks.  Much information on the
Internet is difficult to find.  New improved protocols that might solve
these problems, and others, are hard to phase in because they require
new code to be written for many different platforms, tested, distributed
and installed.  The goal of the Internet, and of computing in general,
should be to get information to where it is needed, when it is needed. 
A software system that embodies this principle would be a good start at
helping the Internet, made of smaller software systems, also do the
same.

It is obvious that existing systems in any combination or organization
are brutally incapable of fulfilling the needs stated above.  If it is
not obvious, you have either not used computers enough, or are ignorant
of the possibilities of how much better it can be (Or, maybe you know of
some systems we don't: Let us know).

So, to create a computing system that gives total control to the user,
is extremely portable, safe, and fast at allowing changes to programs
and to itself, freely available, and moves information where and when it
is needed, we require a redesign of every aspect of computing from the
hardware, the operating system, language, applications, and the user
interface, to the users themselves.  In fact, we need a "whole" system
that redefines all of these components and lets them interact in better
ways.

Here are the main requirements of such a system:

* eliminate the dependence of an application on a single user interface
* eliminate the barriers between programming languages
* eliminate the difference between programmer and user
* specifications, state always available for reflection
* dependency tracking "pushes" information where it is needed

Now, each one in detail:


* eliminate the dependence of an application on a single user interface

When you write a program today you have to write both its functionality
and a user interface.  This practice should end.  TUNES will allow
programmers to be write programs without a user interface, writing an
abstraction layer instead.  Using the TUNES standard abstraction layer
all user interfaces that TUNES supports can access the functionality
that is programmed.  This will allow users to use their interface of
choice at all times, and provide the best accessibility.

The artistic ability of programmers to create their own custom user
interface for each program will not be denied, but all programs will
work detached from the given interface and attached to another.


* eliminate the barriers between programming languages

When I write a program in Perl I have to use "glue" to call the C library.  
And vice versa: when I write in C I do not have easy access to perl
features.  Data types across programming languages have subtly different
semantics.  Fixed-size integer types may be different sizes or have
differing bit-representations.  TUNES will provide a "universal glue" to
allow any language to call any other.  All the languages will be
implemented in TUNES as modules for the system-wide dynamic compiler. Each
language module specifies its own datatypes and provides conversion
to/from its types to/from TUNES native, very expressive typesystem.  This
provides a path between any two types by converting from one language to
the TUNES typesystem, then from the TUNES typesystem to another language.  
TUNES can automatically search for a conversion path and find what values
of a type can be converted without data loss.

The universal calling convention is that the dynamic compiler produces
all the low-level code implementation of every language, and can
therefore move processing flow across language barriers seamlessly at
compile-time (which is right before runtime, with caching of the
compiler result).


* eliminate the difference between programmer and user

If I am a user I am dependent on the whims of a language or library as
to whether an interface is provided.  No more.  TUNES will allow users
to directly access all program interfaces such as library functions and
system calls.  This is possible because there is no need to rely on
binary-only interfaces that are hard for humans to interact with. Since
all interfaces are specified abstractly the user can see and access
them.

As a user of existing systems I am annoyed when I have to repeat some
action in the user interface.  If I go to a web page and there is a list
of files to download, I have to right click and select Save As on every
one of them, or else get a mirroring program.  In TUNES, every user
interface is required to be also accessible by programs. If there's a
menu item or button in a user interface, I can write a program to
activate it in TUNES.  Programmers do not have to add this
functionality, and do not have an option to disable it; the system
provides it.  When using the system you can get a history of the actions
you performed, and save them into a program, and then run it anytime as
a perfectly valid program.


* specifications, state always available for reflection

People have a habit of writing implementations and leaving out
computer-readable specifications.  This is unacceptable in TUNES where the
implementation must be automatically generatable from its specification.  
In TUNES the specification is its source code.  Programmers can make hints
or completely write their implementations as they wish, as long as the
specification is there.

The dynamic compiler can re-implement any part of the system at any
time, so the source code has to be there.  It also has to be there to
prove the system correct according to its specifications.  But the most
important reason is that the user has a right to know exactly what goes
on in his or her own computer.  TUNES will allow the user to inspect and
change any part of the system's source code, and then have the system
re-compile from that code, without any rebooting or manual intervention.

Not just the source code, but the state of the running system can also
be inspected and modified at any time.  This is a system-wide debugger
which will work for any language that is implemented as a language
module.

When there's any doubt about the desirability of changes, the entire
system or any part of it can be run in an emulation box to see what
would happen, and then if it's ok the main system can be overwritten
with the change.

Specifications will be proved correct where possible, and require user
approval to run otherwise.


* dependency tracking "pushes" information where it is needed

All dependencies (such as the implementation's dependency on the source
code and the compiler) will be explicit.  The system will follow
dependencies and automatically propagate changes safely, since all
access to each piece of data is tracked and managed, any other process
trying to access it can be halted while the change is happening.


-- 
Tril 0. Byte <tril@tunes.org> http://tril.tunes.org/
This message is placed in the public domain.