Loading ...
Sorry, an error occurred while loading the content.

L3: Lifestreams, Linda on the Web, and LISP

Expand Messages
  • Mike Beedle
    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
    Message 1 of 3 , Mar 12 1:45 AM
    • 0 Attachment
      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 web.

      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
      network, etc.

      How do you build something like that?

      First let me focus on "Lifestreams" and "Linda on the Web".
      http://www.scopeware.com/home_ie/index_flashie.htm
      http://www.sff.net/people/gunn/gelernter.htm
      http://cs-www.cs.yale.edu/Linda/lifehype/life.html
      http://www.edge.org/documents/archive/edge70.html

      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
      them.
      * Interfaces, or viewports, look at lifestreams
      and work with agents/applications to select/transform/
      edit/redirect infochunks from one stream to another one.
      etc.

      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
      computing problem:

      * 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"
      http://sourceforge.net/projects/portableaserve/
      sitting on a Linux/Windows network trying to build
      something like this.

      Thoughts? Comments?

      - Mike

      ** This btw, is a continuation/extension of the
      POP (pattern-oriented programming) project I started
      a while ago.
    • Mike Beedle
      This may be interesting for the group though it may be old news for some. 1) Molecular Computing The computer is literally life .
      Message 2 of 3 , Mar 25 8:05 AM
      • 0 Attachment
        This may be interesting for the group though it may be
        "old news" for some.

        1) Molecular Computing The computer is literally "life".
        http://www.sciam.com/2000/0600issue/0600reed.html
        http://www.businessweek.com/technology/content/jan2002/tc2002014_0027.htm
        http://www.chemcomp.com/
        http://ls11-www.informatik.uni-dortmund.de/molcomp/
        etc.

        2) Genetic Programming.

        The computer simulates "life".
        http://www.genetic-programming.org
        http://www.geneticprogramming.com/
        etc.


        - Mike
      • patrickdlogan
        ... 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
        Message 3 of 3 , Apr 2, 2002
        • 0 Attachment
          --- 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.

          http://www.roguewave.com/developer/tac/ruple/

          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
          versa.

          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?

          -Patrick Logan
        Your message has been successfully submitted and would be delivered to recipients shortly.