L3: Lifestreams, Linda on the Web, and LISP
- L3 is a vision for doing something cool.
It is in direct contrast with traditional client-server,
prescriptive, RPC-like computing, based on files, file
systems, and databases; that are used to implement
mission-critical applications in the enterprise and on
The vision is to build something that is:
multi-paradigmic, multi-processing, peer-to-peer,
lifestream-based, minimalist, requiring
the least amount of conversions, including
mobility, transparent of data and code over the
How do you build something like that?
First let me focus on "Lifestreams" and "Linda on the Web".
The Lifestreams architecture includes:
* Time-oriented metaphor. Nameless time-oriented
info-chunks arranged in lifestreams make "furniture"
metaphors obsolete: files, file cabinets, etc.
* Peer-to-peer networks. Obsolete client-server
relationships. Peer-to-peer relationships will
go down to PDAs, PCs, local servers, etc.; and will
be capable of exposing access to selected parts
of lifestreams via rules.
* info-chunks are associated with one or
more agents/applications that can do stuff with/for
* Interfaces, or viewports, look at lifestreams
and work with agents/applications to select/transform/
edit/redirect infochunks from one stream to another one.
2. Linda on the Web. The points above try to solve the
data and interface issues. The next point, which is
more challenging, attempts to solve the distributed
* computations take place via tuple spaces in a
distributed "Linda on the Web" way of computing
that is integrated with the Lifestreams.
3. LISP. Why LISP?
1) Distribution. One can send distributed messages
via a LISP-based dialect as a communication protocol.
This is one of the least expensive
serialization/deserialization schemes because:
LISP tuples do _not_ need to be converted back
and forth at the end points of communication.
And there are standard parsers for them. This
basically obsoletes the other XML trickery: DOMs,
XLink, XPath, SOAP, XPointer, XMLSchema, etc.
LISP also provides a transparent to way to do mobility
since rules, functions, classes, objects, patterns,
pattern instances, etc.; can be sent over the wire.
2) LISP allows multi-paradigmic programming including
functions, rules, classes, objects, patterns, pattern
instances, etc.; and makes it possible and easier
to run intelligent agents/applications on the web.
This is specially important in processing lifestreams,
since more intelligent filtering/querying/routing/advice
will be needed. Also, the Linda API, is based primarily
on LISP-like pattern-matching, so it makes sense
to make LISP the programming language.
As of late, I am playing with a LISP-based application
server "Portable Allegro Serve"
sitting on a Linux/Windows network trying to build
something like this.
** This btw, is a continuation/extension of the
POP (pattern-oriented programming) project I started
a while ago.
- This may be interesting for the group though it may be
"old news" for some.
1) Molecular Computing The computer is literally "life".
2) Genetic Programming.
The computer simulates "life".
- --- In feyerabend-project@y..., "Mike Beedle" <beedlem@e...> wrote:
> * Time-oriented metaphor.I've been playing around in this "dimension", so to speak. What if
every many-many association was a time-series? You have access too all
changes over time. Every entity is "versioned" by time, and the
many-many associations are essentially sets of references to each
entities' version in place at the time the association is made.
I don't know much about Lifestreams, except as a presentation
mechanism. Maybe a Lifestream is or could be represented as a
time-series association of data?
> 2. Linda on the Web.I've been playing with this too, using IBM's TSpaces. Although I am
interested in trying Rogue Wave's XML Spaces as well, since it has
more support for XML-based data.
I agree this mechanism has not received its due (yet). Another simple,
powerful tool that follows the principle that the dynamic is better
than the static. Static is a special case of dynamic, and not vice
I am interested to learn how Lifestreams and Tuple Spaces are related?
I know they came from the same lab, and that Tuple Spaces can
coordinate actions and information over time. But what else?
> 3. LISP. Why LISP?Of course. 8^)
I've been using JScheme because it is simple and sits on top of
today's assembler language, Java.
And because, well, it is Lisp. It has adapted well to 40 years of
software technology so why ask why?