A revolutionary OS/Programming Idea

[John Newman]

Lendvai Attila wrote:

"i suggest some serious reading on the tunes.org,
especially the wiki...
you will be either torn apart or ignored on this list
with ideas like
this."

I did do some reading on tunes.org.  I thought that
TUNES concept of 'everything is an object and can have
attributes which are objects' comported well with my
conception of a visual language quite well.  As far as
being torn up, that's what I came here for.  I won't
be offended by some critique.  It may or may not have
been correct to post this idea on this list, but I
think I got some more insightfull feedback here than I
would have gotten elsewhere:)


Lynn H. Maxson wrote:

"In the meantime you might want to shift paradigms in
terms of 
programming languages, leaving the plane of imperative
and 
rising to the level of declarative or logic
programming.  Also 
within imperative languages I would suggest that you
gain an 
understanding of LISP and its more modern dialects."

Seems to be sound advice--will do.  But with a quick
google, I found that there are object oriented
versions of declarative and logic languages.  So, I
don't see why my idea wouldn't work with them as well
(perhaps work better--without all the unnecessary
syntax).


Thank you for your extensive and insightfull response,
Alaric B Snell.  You wrote:

"1) Programming is hard because of the syntax - if
(foo) { wibble(); } 
etc. Make the syntax easier to and everyone can write
code.

2) Rather than always treating source code as a string
of characters, 
treat it as structured data and use a special program
to edit it with a 
proper GUI

(1), sadly, was disproven.

....

The problem appears to be that the main difficulty in
programming is 
the underlying model, not the language you use. If you
are writing an 
application to deal with bulk data, an understanding
of set theory is 
far more important than knowing how to use arrays or
whatnot."


I wasn't meaning to say that a novice could sit down
and suddenly make an OS.  Just make it so that while
navigating their program files they have the option of
navigating deeper into the source code, just as one
would in a normal file system.  If the primitives were
easy enough to learn in an our or two (with no syntax
crap to get hung up on), then the data-structures
would slowly be learned through daily computer use. 
With a few small tutorials one could easily learn to
integrate different aspects of applications
together--or create applications by mixing them.  

For instance, make a file; in it, create a file that
checks the weather forecast (maybe "cin >>
http:www.weather.com); in it, also create an 'if'
file; in the 'if' file, make a file that says "rain" &
"within 24 hours from now" (however your language
would express that); then, in the 'if' file, open the
'then' file (which was already created by the if); in
the 'then' file, drag-n-drop your email client in and
make a 'send' file that says "bring your umbrella" to
all the people in the 'to' file in your 'send' file.


Later, Aleric, you say:

"3) Like the code browser, except that even function
bodies are 
represented diagrammatically, with a GUI editor;
however, this gets 
tricky. I can type "if (foo) {x++;}" faster than I can
right click, 
select "IF", then go to the condition bit, right
click, select 
"variable 
reference", type "foo" (or drag 'foo' from elsewhere
onscreen), go to 
the other bit of the if, right click, select
"INCREMENT", right click 
again, select "variable reference", and type or select
'x'."

This is true, but if I am a novice, that doesn't
understand "if (foo) {x++;}" then I may build the
functions out of the primitives I already understand. 
If I understood the primitives, then I could build my
own incrimenter, or foo, simply by drag-n-drop.  I
could even build the 'if' function myself an use that
file for that purpose, if I was oblivious to the
standard library.

Plus, if we are building with more than one liners,
with as little as even, say, a couple hundred lines of
code, with a few extra one liners, then the
drag-n-drop file system becomes a heck of a lot faster
and easier, since syntax in textual coding would scare
me away from cutting and pasting things where I don't
know if they will fit/compile or not.  It emphesizes
the reuse of data-structures.


Aleric, you also said:

"But you're thinking along the right lines - lots of
aspects of 
programming languages (like being written in text) are
just there 
because of tradition; people have never seen any other
way of doing it 
so they just copy it endlessly... So I reckon that if
you learn more 
history and study some other programming languages
(things like FORTH, 
for example,  have much less of a tree structure than
most languages) 
then you'll be coming up with insights that haven't
been done before!"

Thanks!  The whole reason I am posting here is because
I like what TUNES is all about.  And I find it to be a
noble cause.  Once I am a professional programmer (an
inexolerable end-point that is already in motion), I
plan to contribute extensively to an open source OS. 
It is one of the most noble open source projects I can
think of.  One of the things that I think TUNES prides
itself in is empowering the user with the full power
of their computer.  Making the IDE and the OS one
system is a step in that direction.  It will also make
the OS itself more evolvable, comporting with this
'reflexive' thing I keep hearing so much about.  I
know, this idea wont make a programmer out of a novice
over night, but it brings down various barriers.

I mean, think about it.  The open source collaborative
community would grow exponentially!  Maybe, instead of
just laboriously building software, we should build
tools that make building software less laborious and
less complicated to learn.  In the end, there would be
a lot less work to do for the founding programmers. 
Create an environment that builds itself.



Lynn, you later said:

"You end up with a single "universal" specification
language, 
self-defining and self-extensible.  That means no need
for 
any other language, including assembly language, which
is 
included as machine-dependent specifications for any
given 
platform."

I totally agree with that. Start with a universal set
of primitives, from which all other data-structures
can be contrives.  Let the rest be APIs.

"You need only one software tool also written in the 
specification language:  one language and one tool.   
Supporting this you need to get off file systems and
the use 
of "include" or "copy" statements to the use of a data

repository/directory which the tool uses to
automatically 
maintain source."

How about that "one tool" be integrated into the
structure of the entire OS--liberating everyone to
program.  "include" and "copy" statements, I would
rather not have either--as little as possible would be
nice.  But file-system is so much a "file-system" as
it is just a paradigm for relating and interfacing
objects, whether it's declaritive logic language or
not.

Automatic source maintainance sounds good to me,
though.



And lastly, Aleric, you said:

"Maybe, but it'd be a bit complex ;-) I'd rather study
all the old and 
new languages (although there seems so little to learn
from the new 
ones these days...) and try to make the *simplest
possible* new one that 
combines the wisdom of all the ancients, removing
features that can be 
done better with other features.

Also, I'm a fan of having a very simple language with
a flexible enough 
syntax to make it easy to put things into the standard
libraries, 
rather than in the language core itself."


I couldn't agree more.  The simpler the language is,
the easier it is to understand.  Let even the
conditional statements be files/data-structures that
are built with the core language primatives.  With the
framework I gave, the core functions and their
subsequent data structures would look just like files.
 In effect, any language could be constructed from the
core functions.

Here are a few links to my google search query:
"object oriented" declarative logic programming

http://citeseer.nj.nec.com/ramirez95declarative.html

http://citeseer.nj.nec.com/ng95multiparadigm.html

http://citeseer.nj.nec.com/context/190208/0

http://www.di.unipi.it/~paolo/abstracts/gulp95.abstract.html

http://lambda.weblogs.com/discuss/msgReader$6158

Do you think object oriented logic programming is
implementable under my paradigm of software development?

__________________________________
Do you Yahoo!?
The New Yahoo! Shopping - with improved product search
http://shopping.yahoo.com