[PLA] Concurrency and Elements

[Raphael Langerhorst]

Hello,

this discusses concurrency / multithreading as well as elements (see below), I'm sorry if this will get longer than necessary.

Originally I wanted to write these as PLAs, and I still want to but it seems difficult to put it into the right form (apart from the fact that I was too busy, after all, but we'll ignore this for now, everyone is busy), so I will discuss it here first, informally.

Both relate to each other very much, so I will discuss concurrency from the perspective of elements.


First of all I like the name Programming Language Apocalypse, it makes me think that the time for programming languages is over (Apocalypse), something I actually agree with in a sense that programming languages will not for long remain the highest level for defining computer intelligence (now, don't tell me there already is MDA or whatever, these things still on the same level).


Ok, so, elements. Consider the following scenario (which I like a lot, and its not far off anymore). Layers of technology/abstraction: the lowest is the computing hardware. In early days, everyone directly used the hardware (punchcards, assembler, etc. etc.). Some decades later, operating systems were introduced (remember UNIX). Up to now (30 to 40 years later), we still have operating systems as the highest layer. Files and Applications (read: processes) are the content of operating systems. Every user is using an operating system, right? And how many users really understand the operating system?

Now, for the scenario we go further, let's assume there is an user environment (the third layer, on top of hardware and the operating system). The content of this layer is called elements. An element is an intelligent piece of structured information. That is, it holds information and shows some sort of behaviour (the intelligence). In addition elements are structured (tree) and can relate to another elements - think of a mind map, it will get you close enough.

What's the use? In short, users now have to deal with the operating system (even if its nicely wrapped in a desktop environment, it doesn't change the fact). Because of this they are confronted with the concepts of the operating system (applications, files, files system, desktop, icons, menus, strange panels, ... network, internet, ...) most of which they simply have no chance to fully understand.

In contrast, given the user environment, elements are the only thing there is and the only thing that is needed. Because the only thing users really want to deal with is information - the way they can deal with it is defined through the intelligence/behaviour of the elements that hold the information. Thus no need for anything else and no need to confront the user with operating system concepts (that are unnatural to the user - especially the unencumbered user). In addition the environment is spanned accross all machines on the net. So there really is only one gigantic worldwide user environment with elements as content.


So... in that scenario, what do I need a programming language for? Guess. In order to define the behaviour/intelligence of elements (I call them agents). It is the one and only type of software that is relevant in that scenario (right now it is also necessary to write views, but we'll ignore this for clarity... and I would consider views part of the layer/system implementation - essentially).

Now, why would I need to define intelligence with written text (that is, a programming language) at all? Just because it's the only way to teach a computer? I personally consider this a technological constraint. Still, it may be necessary (after all, the computer needs to work somehow). I do not really have an answer to the question.


If we take a look at concurrency now, the whole thing gets a different perspective. Where is the actual application? The single process? No one is interested in the application! There is only intelligence working on (or within) the element. Think of the human world population. Every human being is thinking concurrently, no? Relations exist between humans (among other things) thereby influencing each other (asynchronously from a technical perspective I guess, although it may be synchronous in reality). The behaviour processing of one being does not interfere at all with the behaviour processing of another being. In other words, the agent process/thread of one element has nothing todo (shared memory, sequential processing, ...) with the process/thread of another agent on another element - even another agent on the same element (?? which means I'm not sure if this is doable to have them independent even on the same element).

A side note: distribution is another consideration I will not discuss here.


All this has two effects: The programming language (if it really is a language) must naturally include concurrency and be suitable define agents that work with elements (right now this mainly means to work with XML, however (!!) there is no reason why there should be only text (xml) content - and don't tell me about including multimedia file formats in xml - since the human being - the user after all - really works visually, auditorially (spellcheck that) and all kinds of things).

I cannot see how the second requirement (beyond XML only) can be achieved, but... since I can post arbitrary feature requests I can just as well say what I want, maybe some genious finds out how to do it. Maybe to elaborate on that... things exist, and everything that exists has many aspects. Take a book, it has text in it (yeah), but it also has a certain look, especially if it has pictures. So we can read a book (text), or look at it (visual). Take water, we can look at it (a little bit at least), feel it, taste it, hear it, ...). Things really simply exist and they have different aspects that can be  used to perceive it in some ways. But in essence a thing is always itself... on a higher level all things share a similar/single aspect, that of simply being/existing - an aspect that is very real, we are just too much used to interpret a thing by the means of our physical senses which by no means(!!) get to the essence of anything.

Maybe I can put this in a sensible feature request: Provide a language that makes it possible or easy to handle things that exist but may be perceived or used in different ways... whoa, maybe not that easy or clear. With this I do not mean whether something is a number or a string (I'm way beyond that), but in the sense of sensory... ehm... yeah, maybe. Ah... sensory... maybe that's a starting point. It would essentially remove the need for views which I have ignored above (views are only necessary due to technical limitations of the underlying technology... in this case programming languages).



I will begin to sum up. First, get used to the element concept and user environments. From that point on consider concurrency (individual points of behaviour/intelligence within a larger environment). This also means I do not need a programming language that has modules for everything and wraps all system APIs... we are beyond operating systems now and it is very important (honestly!!) to consider the design of a programming language (if it has to be a language) from a higher perspective. To be clear: I do not need a language that does all that (I know how to do it), I just need a language that makes it possible to do all that (SPL is, in fact, close, but severely fails at concurrency and does not support the fancy perspectives I talked about above).


Regarding perspecitves: maybe the approach with operators is slightly going in the right direction.

Regarding concurrency: to get you going, take a look at http://www.erlang.org
Important lead-in: http://www.pragmaticprogrammer.com/articles/erlang.html


Everything is subject to discussion/feedback. If this programming language makes it possible to go beyond programming languages (that is, it is the last programming language that is necessary) then its goal (for my needs) are achieved. For other purposes I think (honestly) that there are already too many really similar languages that just have a different syntax and community.

Note: In terms of SPL I would need the following additional features: Concurrency, everything else is fine enough (Although I have a list with about 10 small feature requests I will need to get through one day, minor things only, nothing to worry about).

If you need more info on elements let me know, too.


Best Reagards,
Raphael
-- 
Der GMX SmartSurfer hilft bis zu 70% Ihrer Onlinekosten zu sparen! 
Ideal für Modem und ISDN: http://www.gmx.net/de/go/smartsurfer