Dear Madam/Sir,
you are working on a new web based Operating System and I think now that it is
possible to set up the first initials of what I call a "Web Of Data And
Functions" and that in webdocuments** of others is called "web of services",
"grid workflow", "swarmOS" etc. The initial framework exists of three projects:
the (as of this moment) device-developed "Calamity Jane Express"(CJE)-project
plus the cloud-developed "!Yahoo Pipes"-("Wiring The Web") project plus a small
so-called "Missing Link" to close the gap between the aforementioned two
projects. All projects are "bullet"-drag/drop based, but it is the small
"Missing Link"-project that actually should make it possible to "scrape"
bullets from the !Yahoo Pipes cloud-service (or any other external service)
onto a CJE-bullet-user-interface installed device and vice versa (if allowed
so). Voila, data and functionality on-the-fly! Now I wonder, after reading the
attachment, whether you think it could also somehow
be implemented in your web-based OS. The "Calamity Jane Express"(R) is a
MIT-licensed open source project, so it can be adapted and used in any way.
Also anyone can use the endresults that are fabricated with !Yahoo-Pipes by
developers (e.g. in rss, json-format, though not yet visualizwed with
"scrapable bullets"). Details of the websites of interest and email is given
below.
Many thanks in advance and hopefully to hear from you soon,
Kind Regards,
Dee Jay Alexander
email-1: [email protected]
email-2: [email protected]
web-site: www.calamityjaneexpress.net
introduction and articles: calamityjaneexpress.wordpress.com
twitter: @DJACJE
*: "Calamity Jane Express" is a registered trademark in the US and other
countries since 1999.
**Interesting webpapers concerning "swarmOS", "omnipresent web of
functionality", "web-grid of workflow", "intelligent cities" etc that I sent an
email:
Semi-Automatic Web Service Generation; authors: {chema.fuentes, miguel.corella,
pablo.castells, mariano.rico}@uam.es
Semantic Web Service Selection Using Particle Swarm Optimization (Pso);
authors: S.K.Yaamini ([email protected])
A survey on bio-inspired algorithms for web service composition; authors:
Lijuan Wang ([email protected]), Jun Shen ([email protected])
QoS Scheduling Algorithm Based on Hybrid Particle Swarm Optimization Strategy
for Grid Workflow; authors: Chunhua Hu ([email protected])
A Particle Swarm-based Web Service Dynamic Selection Algorithm with QoS Global
Optimal; authors: Kai Zheng ([email protected]), Hailing Xiong
([email protected])
The TerraSwarm Research Center (TSRC) (A White Paper); author: Electrical
Engineering and Computer Sciences University of California at Berkeley; Edward
A. Lee ([email protected])
Sent from Yahoo! Mail on Android
Realization of a basic WODAF/CJE(1) framework.
The initial framework exists of three projects: the (as of this moment)
device-developed "Calamity Jane Express"(R)-project plus the cloud-developed
"!Yahoo Pipes"-project plus a small so-called "Missing Link" to close the gap
between the aforementioned two projects. All projects are "bullet"-drag/drop
based, but it is the small "Missing Link"-project that actually should make it
possible to "scrape" bullets from the !Yahoo Pipes cloud-service (or any other
external service) onto a CJE-bui-installed device and vice versa (if allowed
so). Voila, data and functionality on-the-fly! This is extremely usefull in an
emergency situation to be able to set up some ad-hoc mesh network.
Like stated before, the WODAF/CJE framework can already realized in, be it in a
basic form, since two existing projects can already deliver most basic
materials: The "Calamity Jane Express"(R) project and the "!Yahoo Pipes"
project. A third "project", here called the "Missing Link" must be added to get
it done.
"Calamity Jane Express"(R) concept-summary.
On the display, (passive) data- and (executable) functions, are being
represented as uniform relocatable so-called "bullets", since they have a
bullet-like shape, that can simple be dragged/dropped within and between
so-called "clips". A clip is just a bunch of bullets "closely packed together"
(like they belong to some category, class etc). This way, the "calamity Jane
Express"(R) user-interface is a bullet-user-interface, named CJE-bui.
Presently, on an Android smartphone, the CJE-bui has a maximum of two "clips"
on top of each other (:UPPER-CLIP/LOWER-CLIP). Devices with larger screens
might have more clips plus a visible so-called common canvas, an space that is
omni-addressable by any bullet (if allowed so), where these bullets can
"explode" their content. Clips can contain sub-clips that also have the shape
of a bullet, but then are called pseudo-bullets. Tapping/clicking on such a
pseudo-bullet loads a new clip with bullets, that replaces the original ones.
This way you can traverse from clip to clip. Clips can have multiple sub-clips,
or children, and multiple parents. Like said, bullets can freely be relocated,
by drag/drop, within and between clips. The clips only contain data/references
to the local device.
Under the hood and in web-terms, a bullet is actually nothing but a list-item
"<li />" and a clip is nothing but a listview "<ul />".
On a smartphone with two clips visible, in web/HTML terms, it looks something
like this:
...
<ul>
<li..................</li>
... (UPPER-CLIP)
<li..................</li>
</ul>
... (<li...</li> on
the display represented as bullets that can be dragged/dropped from LOWER- to
UPPER-CLIP and saved locally)
<ul>
<li..................</li>
... (LOWER-CLIP)
<li..................</li>
</ul>
...
"!Yahoo Pipes" concept-summary.
With "!Yahoo Pipes" you can re-process data coming from different sites into
some desired end-result. The re-processing "actors" are represented by
configurable and 2-dimensional relocatable bullets, with which to define the
data-reprocessing, that can be interconnected to set up a re-workable
data-stream between them. This can be done in a relatively convenient way but
with some learning curve, although definitely not steep. Everyone with a Yahoo
account can fabricate it and everyone else, account or not may use it. The
"product/service" is a so-called "pipe" and the end-user might even provide
parameters to it. You can even select whether you want the result returned to
you as email, RSS- or JSON-format etc. And all finally represented by a
copyable link. When you tap/click on it, voilà , the results or returned to you
in e.g. JSON-format. Even for a non-novice (like me) it might take some time to
find out how things work.
But, they are already using bullets to compose a pipe. Now what if the
"pipe"-link also would be presented as a bullet, lined up with other bullets in
some clip, that could easily be dragged and dropped to your local device and
maybe even vice-versa, when allowed so?
Pipe-links that can be copied and used by everyone, looks something like this,
provided with the necessary parameters (and if e.g. JSON-format is chosen):
http://pipes.yahoo.com/pipes/pipe.run?_id=VEm5_4253BGSBceQJphxuA&_render=json&filterCriteria1=flood&zoneCode=TXZ16
(from: Weather alert!).
http://pipes.yahoo.com/pipes/pipe.run?_id=vkbigS9w3BGFQgxmLe2fWQ&_render=json
(from: FEMA Regional News)
http://pipes.yahoo.com/pipes/pipe.run?State=WI&_id=Sk81h4cH3RGl44WkJZhxuA&_render=json
(from: National Severe Thunderstorm Warnings)
http://pipes.yahoo.com/pipes/pipe.run?_id=xL2ZsmPI2xGZEhiNkAtvUw&_render=json
(from: Wildfire News)
"Missing-Link" concept summary.
The "Missing-Link" is a mechanism that might work as follows:
A special "!Yahoo-Pipes" bullet that is locally on the device, when
tapped/clicked, sends via AJAX a link with a special parameter, e.g. wodaf=yes
and receive=yes, to the "!Yahoo Pipes"-site, like:
http://pipes.yahoo.com/pipes/pipe.run?_wodaf=yes&receive=yes. What is being
returned looks, in web/HTML terms, something like this:
...
<ul>
<li..................</li>
...
<li..................</li>
</ul>
...
... and is via AJAX directly inserted in the LOWER-CLIP and presented to the
user as a clip with relocatable bullets, that can be selected and inspected for
its contents (data and/or functionality), then selected and dragged to the
UPPER-CLIP. It may look something like this:
...
<ul>
<li...http://pipes.yahoo.com/pipes/pipe.run?_id=VEm5_4253BGSBceQJphxuA&_render=json&filterCriteria1=flood&zoneCode=TXZ16</li>
...
<li...http://pipes.yahoo.com/pipes/pipe.run?_id=vkbigS9w3BGFQgxmLe2fWQ&_render=json</li>
</ul>
...
You can now save the clip locally as usual. Next time when you recall this clip
and its bullets and you tap on some "!Yahoo Pipe"-bullet, this link-bullet is
fired into the "!Yahoo Pipe"-website, processed there by e.g. the "Weather
Alert!"-pipe, and its result is then sent back to you where it might be further
processed.
For the novice it would be nice if the result could be directly displayed on
the display in some comprehensible and attractive way, instead of having to
fiddle with some "abracadabra" JSON-data. Vice-versa should then also be
possible: submitting clips with bullets, like forms, to other devices and/or
sites, or the other party takes the initiative and loads clips with bullets
from your device, when allowed so. While traversing from (remote) clip to
(remote) clip, you may now drag/drop bullets that you like to your local device
and save them and/or vice versa. As of this moment only the
data/reference/links within the bullets(/list-items) are saved and not some
remote data/file/script it might refer to. But this should be possible too in a
future release. In that case when a link-bullet to some remote site is
tapped/clicked, the remote data/file/script will not directly be streamed to
the display or speakers, but just stored on your local device. As of this
moment it also not yet possible to provide parameters on the fly.
Conclusion.
With minimal programming effort it should now be possible, be it in an initial
basic way, to drag & drop data- and function-bullets to and from others
on-the-fly! Like stated before, this is exactly why the "Calamity Jane
Express"(R)-project was created: when in some emergency situation and when the
default network is down or jammed, being able to set-up some local (wireless)
ad-hoc communication network, where one can make use of each others data and
functionality on-the-fly.
There is one catch however, a local on-board, be it minimalistic, cgi-server
must be present to make this possible. Hopefully this will be integrated by
default by any future (web-based) OS.
(1) WODAF: Web Of Data And Functions; CJE: Calamity Jane Express(R)
_______________________________________________
dev-b2g mailing list
[email protected]
https://lists.mozilla.org/listinfo/dev-b2g
