Path: utzoo!attcan!utgpu!jarvis.csri.toronto.edu!mailrus!uwm.edu!gem.mps.ohio-state.edu!tut.cis.ohio-state.edu!ucbvax!CSE.OGC.EDU!wm
From: wm@CSE.OGC.EDU (Wm Leler)
Newsgroups: comp.sys.transputer
Subject: Re:  Strand88
Message-ID: <8910161650.AA06916@cse.ogc.edu>
Date: 16 Oct 89 16:50:55 GMT
Sender: daemon@ucbvax.BERKELEY.EDU
Organization: The Internet
Lines: 65

I have to throw in my two cents worth about Strand.

The Stand Software Technologies people came out for a visit last
Friday and gave us a demonstration.  I must say that I was impressed.

Declarative languages like Strand have been around for a while, but
despite their benefits haven't become popular yet.  I believe that
their advantages in terms of parallel execution might be just the thing
that gives them a break.  In addition to parallel logic programming
languages like Strand, there has been quite a bit of work with (purely)
functional languages (e.g., Paul Hudak's), and even more esoteric
languages, like constraint languages (consider that a plug for my
book!).

I don't consider Linda and Strand to be competitors, any more than
Prolog and C are competitors.  Each language has its purposes,
advantages and disadvantages.  In addition, Strand is a language, while
Linda is a set of communications primitives that you add to an existing
language.  We have added (a version of) Linda to C++, C, FORTRAN, and
(even) PostScript, and it is entirely reasonable to add a binding to
Strand (although you would lose some of the declarative reading of
Strand).  You could also write an implementation of Strand that uses
Linda (in particular, Strand could benefit from some of the work we
have done on using an oracle for process placement).

Currently (I believe this can change in the future) Strand88 is an
interpreted language, although you can call routines that are compiled
from other languages (including C, FORTRAN, and -- soon -- COBOL!).  I
like Strand's ability to combine different languages into a single
program.  Currently this is done statically (you have to relink
Strand with the modules written in other languages) but I think that
you could use Linda (at last Kernel Linda) to do this "linking" dynamically.

Linda and Strand would work well together.

Just to generate some discussion about Strand (and if you haven't read
the book yet, get it!) I throw out the following questions.

In Strand, even though a program has a declarative reading, "or"
parallelism is handled sequentially.  This means that the following
program:

 foo(X) :- X>0 | do_something.
 foo(X) :- otherwise | do_something_else.

will execute the same as this program, although they have different
readings.

 foo(X) :- X>0 | do_something.
 foo(X) :- true | do_something_else.

I can justify this by saying that the second program is wrong, so
we don't care if it executes the same as a correct program.  But my
question is, is there a program that will not execute correctly, or
must be written differently, because the different "or" clauses are
executed in order?

My only other comment is that I wish that streams in Strand were a 
little more explicit, rather than doing the standard hack (?) of a
procedure calling itself at the last moment.  In particular, in using
such a routine from the keyboard you have to keep inventing new
variable names for the stream.

Wm Leler
Cogent Research, Inc.