## Swarm- distributed stack based programming language

Ian Clarke presents the prototype for Swarm -a distributed stack based programming language to be written in Scala. The fundamental concept behind Swarm is that we should "move the computation, not the data".

## Comment viewing options

### Process migration has been around for a long time

What is the difference between this system and things like termite scheme ?
A very similar system based on stack was implemented a some time ago using postscript called Tps.

Edit: [Also see Agent TCL and Oz]

### In Swarm the process is transparent

So far as I can tell, the process migration you refer to must be initiated manually. In Swarm, the process migration is entirely transparent to the programmer - the process follows the data - and the data is moved around to maximize efficiency.

### API or a language?

I read in your blog comments [reference to the object contains the node that is storing the object.], if that is the case a sequence of calls in swarm will be

  getval[node1://k1] + getval[node2://k2]


cant this be done by an API as

 getval[node,k] = migrate[node] ; get[local://k]


using the above systems I quoted, transparent to the programmer?

### perhaps misunderstanding

I may be misunderstanding you, but if you have to explicitly say "migrate[node]" then its not transparent to the programmer. The point is that the programmer doesn't know or care whether the object is local or remote (or, more precisely, it will always be local because the computation moves as required).

### edge of [OT]

To clarify:
Say the user has submitted a program below,

add(map[key1], map[key2])


As the first step in execution, the nodes holding values of keys key1 and key2 need to be located first (by your system, not the programmer). This lookup would be the most critical part of the system (This is the impression I got from your page - let me know if this is incorrect). Once it is done, the program would be translated to

add(map[node1://key1], map[node2://key2])


where the keys contain the reference to node where the value live. From here, it is same as any of the others (as mentioned in the previous post).

--
Since language specific implementation details is off topic here, it may be better to move this thread to your blog.